src/agents/synthesis_agent.py

"""
Enhanced Synthesis Agent with Expert Consultant Assignment
Based on skill probability scores from Skills Identification Agent
"""

import logging
import json
from typing import Dict, List, Any, Optional, Tuple
from datetime import datetime
import re

logger = logging.getLogger(__name__)


class ExpertConsultantAssigner:
    """
    Assigns expert consultant profiles based on skill probabilities
    and generates weighted expertise for response synthesis
    """
    
    # Expert consultant profiles with skill mappings
    EXPERT_PROFILES = {
        "data_analysis": {
            "title": "Senior Data Analytics Consultant",
            "expertise": ["Statistical Analysis", "Data Visualization", "Business Intelligence", "Predictive Modeling"],
            "background": "15+ years in data science across finance, healthcare, and tech sectors",
            "style": "methodical, evidence-based, quantitative reasoning"
        },
        "technical_programming": {
            "title": "Principal Software Engineering Consultant", 
            "expertise": ["Full-Stack Development", "System Architecture", "DevOps", "Code Optimization"],
            "background": "20+ years leading technical teams at Fortune 500 companies",
            "style": "practical, solution-oriented, best practices focused"
        },
        "project_management": {
            "title": "Strategic Project Management Consultant",
            "expertise": ["Agile/Scrum", "Risk Management", "Stakeholder Communication", "Resource Optimization"],
            "background": "12+ years managing complex enterprise projects across industries",
            "style": "structured, process-driven, outcome-focused"
        },
        "financial_analysis": {
            "title": "Executive Financial Strategy Consultant",
            "expertise": ["Financial Modeling", "Investment Analysis", "Risk Assessment", "Corporate Finance"],
            "background": "18+ years in investment banking and corporate finance advisory",
            "style": "analytical, risk-aware, ROI-focused"
        },
        "digital_marketing": {
            "title": "Chief Marketing Strategy Consultant",
            "expertise": ["Digital Campaign Strategy", "Customer Analytics", "Brand Development", "Growth Hacking"],
            "background": "14+ years scaling marketing for startups to enterprise clients",
            "style": "creative, data-driven, customer-centric"
        },
        "business_consulting": {
            "title": "Senior Management Consultant",
            "expertise": ["Strategic Planning", "Organizational Development", "Process Improvement", "Change Management"],
            "background": "16+ years at top-tier consulting firms (McKinsey, BCG equivalent)",
            "style": "strategic, framework-driven, holistic thinking"
        },
        "cybersecurity": {
            "title": "Chief Information Security Consultant",
            "expertise": ["Threat Assessment", "Security Architecture", "Compliance", "Incident Response"],
            "background": "12+ years protecting critical infrastructure across government and private sectors",
            "style": "security-first, compliance-aware, risk mitigation focused"
        },
        "healthcare_technology": {
            "title": "Healthcare Innovation Consultant",
            "expertise": ["Health Informatics", "Telemedicine", "Medical Device Integration", "HIPAA Compliance"],
            "background": "10+ years implementing healthcare technology solutions",
            "style": "patient-centric, regulation-compliant, evidence-based"
        },
        "educational_technology": {
            "title": "Learning Technology Strategy Consultant",
            "expertise": ["Instructional Design", "EdTech Implementation", "Learning Analytics", "Curriculum Development"],
            "background": "13+ years transforming educational experiences through technology",
            "style": "learner-focused, pedagogy-driven, accessibility-minded"
        },
        "environmental_science": {
            "title": "Sustainability Strategy Consultant",
            "expertise": ["Environmental Impact Assessment", "Carbon Footprint Analysis", "Green Technology", "ESG Reporting"],
            "background": "11+ years driving environmental initiatives for corporations",
            "style": "sustainability-focused, data-driven, long-term thinking"
        }
    }
    
    def assign_expert_consultant(self, skill_probabilities: Dict[str, float]) -> Dict[str, Any]:
        """
        Create ultra-expert profile combining all relevant consultants
        
        Args:
            skill_probabilities: Dict mapping skill categories to probability scores (0.0-1.0)
            
        Returns:
            Dict containing ultra-expert profile with combined expertise
        """
        if not skill_probabilities:
            return self._get_default_consultant()
        
        # Calculate weighted scores for available expert profiles
        expert_scores = {}
        total_weight = 0
        
        for skill, probability in skill_probabilities.items():
            if skill in self.EXPERT_PROFILES and probability >= 0.2:  # 20% threshold
                expert_scores[skill] = probability
                total_weight += probability
        
        if not expert_scores:
            return self._get_default_consultant()
        
        # Create ultra-expert combining all relevant consultants
        ultra_expert = self._create_ultra_expert(expert_scores, total_weight)
        
        return {
            "assigned_consultant": ultra_expert,
            "expertise_weights": expert_scores,
            "total_weight": total_weight,
            "assignment_rationale": self._generate_ultra_expert_rationale(expert_scores, total_weight)
        }
    
    def _get_default_consultant(self) -> Dict[str, Any]:
        """Default consultant for general inquiries"""
        return {
            "assigned_consultant": {
                "primary_expertise": "business_consulting",
                "title": "Senior Management Consultant",
                "expertise": ["Strategic Planning", "Problem Solving", "Analysis", "Communication"],
                "background": "Generalist consultant with broad industry experience",
                "style": "balanced, analytical, comprehensive",
                "secondary_expertise": [],
                "confidence_score": 0.7
            },
            "expertise_weights": {"business_consulting": 0.7},
            "total_weight": 0.7,
            "assignment_rationale": "Default consultant assigned for general business inquiry"
        }
    
    def _create_ultra_expert(self, expert_scores: Dict[str, float], total_weight: float) -> Dict[str, Any]:
        """Create ultra-expert profile combining all relevant consultants"""
        
        # Sort skills by probability (highest first)
        sorted_skills = sorted(expert_scores.items(), key=lambda x: x[1], reverse=True)
        
        # Combine all expertise areas with weights
        combined_expertise = []
        combined_background_elements = []
        combined_style_elements = []
        
        for skill, weight in sorted_skills:
            if skill in self.EXPERT_PROFILES:
                profile = self.EXPERT_PROFILES[skill]
                
                # Weight-based contribution
                contribution_ratio = weight / total_weight
                
                # Add expertise areas with weight indicators
                for expertise in profile["expertise"]:
                    weighted_expertise = f"{expertise} (Weight: {contribution_ratio:.1%})"
                    combined_expertise.append(weighted_expertise)
                
                # Extract background years and combine
                background = profile["background"]
                combined_background_elements.append(f"{background} [{skill}]")
                
                # Combine style elements
                style_parts = [s.strip() for s in profile["style"].split(",")]
                combined_style_elements.extend(style_parts)
        
        # Create ultra-expert title combining top skills
        top_skills = [skill.replace("_", " ").title() for skill, _ in sorted_skills[:3]]
        ultra_title = f"Visionary Ultra-Expert: {' + '.join(top_skills)} Integration Specialist"
        
        # Combine backgrounds into comprehensive experience
        total_years = sum([self._extract_years_from_background(bg) for bg in combined_background_elements])
        ultra_background = f"{total_years}+ years combined experience across {len(sorted_skills)} domains: " + \
                          "; ".join(combined_background_elements[:3])  # Limit for readability
        
        # Create unified style combining all approaches
        unique_styles = list(set(combined_style_elements))
        ultra_style = ", ".join(unique_styles[:6])  # Top 6 style elements
        
        return {
            "primary_expertise": "ultra_expert_integration",
            "title": ultra_title,
            "expertise": combined_expertise,
            "background": ultra_background,
            "style": ultra_style,
            "domain_integration": sorted_skills,
            "confidence_score": total_weight / len(sorted_skills),  # Average confidence
            "ultra_expert": True,
            "expertise_count": len(sorted_skills),
            "total_experience_years": total_years
        }
    
    def _extract_years_from_background(self, background: str) -> int:
        """Extract years of experience from background string"""
        years_match = re.search(r'(\d+)\+?\s*years?', background.lower())
        return int(years_match.group(1)) if years_match else 10  # Default to 10 years
    
    def _generate_ultra_expert_rationale(self, expert_scores: Dict[str, float], total_weight: float) -> str:
        """Generate explanation for ultra-expert assignment"""
        sorted_skills = sorted(expert_scores.items(), key=lambda x: x[1], reverse=True)
        
        rationale_parts = [
            f"Ultra-Expert Profile combining {len(sorted_skills)} specialized domains",
            f"Total expertise weight: {total_weight:.2f} across integrated skill areas"
        ]
        
        # Add top 3 contributions
        top_contributions = []
        for skill, weight in sorted_skills[:3]:
            contribution = (weight / total_weight) * 100
            top_contributions.append(f"{skill} ({weight:.1%}, {contribution:.0f}% contribution)")
        
        rationale_parts.append(f"Primary domains: {'; '.join(top_contributions)}")
        
        if len(sorted_skills) > 3:
            additional_count = len(sorted_skills) - 3
            rationale_parts.append(f"Plus {additional_count} additional specialized areas")
        
        return " | ".join(rationale_parts)


class EnhancedSynthesisAgent:
    """
    Enhanced synthesis agent with expert consultant assignment
    Compatible with existing ResponseSynthesisAgent interface
    """
    
    def __init__(self, llm_router, agent_id: str = "RESP_SYNTH_001"):
        self.llm_router = llm_router
        self.agent_id = agent_id
        self.specialization = "Multi-source information integration and coherent response generation"
        self.expert_assigner = ExpertConsultantAssigner()
        self._current_user_input = None
        
    async def execute(self, user_input: str = None, agent_outputs: List[Dict[str, Any]] = None, 
                     context: Dict[str, Any] = None, skills_result: Dict[str, Any] = None,
                     **kwargs) -> Dict[str, Any]:
        """
        Execute synthesis with expert consultant assignment
        Compatible with both old interface (agent_outputs first) and new interface (user_input first)
        
        Args:
            user_input: Original user question
            agent_outputs: Results from other agents (can be first positional arg for compatibility)
            context: Conversation context
            skills_result: Output from skills identification agent
            
        Returns:
            Dict containing synthesized response and metadata
        """
        # Handle backward compatibility and normalize arguments
        # Case 1: First arg is agent_outputs (old interface)
        if isinstance(user_input, list) and agent_outputs is None:
            agent_outputs = user_input
            user_input = kwargs.get('user_input', '')
            context = kwargs.get('context', context)
            skills_result = kwargs.get('skills_result', skills_result)
        # Case 2: All args via kwargs
        elif user_input is None:
            user_input = kwargs.get('user_input', '')
            agent_outputs = kwargs.get('agent_outputs', agent_outputs)
            context = kwargs.get('context', context)
            skills_result = kwargs.get('skills_result', skills_result)
        
        # Ensure user_input is a string
        if not isinstance(user_input, str):
            user_input = str(user_input) if user_input else ''
        
        # Default agent_outputs to empty list and normalize format
        if agent_outputs is None:
            agent_outputs = []
        
        # Normalize agent_outputs: convert dict to list if needed
        if isinstance(agent_outputs, dict):
            # Convert dict {task_name: result} to list of dicts
            normalized_outputs = []
            for task_name, result in agent_outputs.items():
                if isinstance(result, dict):
                    # Add task name to the result dict for context
                    result_with_task = result.copy()
                    result_with_task['task_name'] = task_name
                    normalized_outputs.append(result_with_task)
                else:
                    # Wrap non-dict results
                    normalized_outputs.append({
                        'task_name': task_name,
                        'content': str(result),
                        'result': str(result)
                    })
            agent_outputs = normalized_outputs
        
        # Ensure it's a list
        if not isinstance(agent_outputs, list):
            agent_outputs = [agent_outputs] if agent_outputs else []
        
        logger.info(f"{self.agent_id} synthesizing {len(agent_outputs)} agent outputs")
        if context:
            interaction_count = len(context.get('interaction_contexts', [])) if context else 0
            logger.info(f"{self.agent_id} context has {interaction_count} interaction contexts")
            
        # STEP 1: Extract skill probabilities from skills_result
        skill_probabilities = self._extract_skill_probabilities(skills_result)
        logger.info(f"Extracted skill probabilities: {skill_probabilities}")
        
        # STEP 2: Assign expert consultant based on probabilities
        consultant_assignment = self.expert_assigner.assign_expert_consultant(skill_probabilities)
        assigned_consultant = consultant_assignment["assigned_consultant"]
        logger.info(f"Assigned consultant: {assigned_consultant['title']} ({assigned_consultant.get('primary_expertise', 'N/A')})")
        
        # STEP 3: Generate expert consultant preamble
        expert_preamble = self._generate_expert_preamble(assigned_consultant, consultant_assignment)
        
        # STEP 4: Build synthesis prompt with expert context
        synthesis_prompt = self._build_synthesis_prompt_with_expert(
            user_input=user_input,
            context=context,
            agent_outputs=agent_outputs,
            expert_preamble=expert_preamble,
            assigned_consultant=assigned_consultant
        )
        
        logger.info(f"{self.agent_id} calling LLM for response synthesis")
        
        # Call LLM with enhanced prompt
        try:
            response = await self.llm_router.route_inference(
                task_type="response_synthesis",
                prompt=synthesis_prompt,
                max_tokens=2000,
                temperature=0.7
            )
            
            # Only use fallback if LLM actually fails (returns None, empty, or invalid)
            if not response or not isinstance(response, str) or len(response.strip()) == 0:
                logger.warning(f"{self.agent_id} LLM returned empty/invalid response, using fallback")
                return self._get_fallback_response(user_input, agent_outputs, assigned_consultant)
            
            clean_response = response.strip()
            logger.info(f"{self.agent_id} received LLM response (length: {len(clean_response)})")
            
            # Build comprehensive result compatible with existing interface
            result = {
                "synthesized_response": clean_response,
                "draft_response": clean_response,
                "final_response": clean_response,  # Main response field - used by UI
                "assigned_consultant": assigned_consultant,
                "expertise_weights": consultant_assignment["expertise_weights"],
                "assignment_rationale": consultant_assignment["assignment_rationale"],
                "source_references": self._extract_source_references(agent_outputs),
                "coherence_score": 0.90,
                "improvement_opportunities": self._identify_improvements(clean_response),
                "synthesis_method": "expert_enhanced_llm",
                "agent_id": self.agent_id,
                "synthesis_quality_metrics": self._calculate_quality_metrics({"final_response": clean_response}),
                "synthesis_metadata": {
                    "agent_outputs_count": len(agent_outputs),
                    "context_interactions": len(context.get('interaction_contexts', [])) if context else 0,
                    "user_context_available": bool(context.get('user_context', '')) if context else False,
                    "expert_enhanced": True,
                    "processing_timestamp": datetime.now().isoformat()
                }
            }
            
            # Add intent alignment if available
            intent_info = self._extract_intent_info(agent_outputs)
            if intent_info:
                result["intent_alignment"] = self._check_intent_alignment(result, intent_info)
            
            return result
            
        except Exception as e:
            logger.error(f"{self.agent_id} synthesis failed: {str(e)}", exc_info=True)
            return self._get_fallback_response(user_input, agent_outputs, assigned_consultant)
    
    def _extract_skill_probabilities(self, skills_result: Dict[str, Any]) -> Dict[str, float]:
        """Extract skill probabilities from skills identification result"""
        if not skills_result:
            return {}
        
        # Check for skill_classification structure
        skill_classification = skills_result.get('skill_classification', {})
        if 'skill_probabilities' in skill_classification:
            return skill_classification['skill_probabilities']
        
        # Check for direct skill_probabilities
        if 'skill_probabilities' in skills_result:
            return skills_result['skill_probabilities']
        
        # Extract from identified_skills if structured differently
        identified_skills = skills_result.get('identified_skills', [])
        if isinstance(identified_skills, list):
            probabilities = {}
            for skill in identified_skills:
                if isinstance(skill, dict) and 'skill' in skill and 'probability' in skill:
                    # Map skill name to expert profile name if needed
                    skill_name = skill['skill']
                    probability = skill['probability']
                    probabilities[skill_name] = probability
                elif isinstance(skill, dict) and 'category' in skill:
                    skill_name = skill['category']
                    probability = skill.get('probability', skill.get('confidence', 0.5))
                    probabilities[skill_name] = probability
            return probabilities
        
        return {}
    
    def _generate_expert_preamble(self, assigned_consultant: Dict[str, Any], 
                                 consultant_assignment: Dict[str, Any]) -> str:
        """Generate expert consultant preamble for LLM prompt"""
        
        if assigned_consultant.get('ultra_expert'):
            # Ultra-expert preamble
            preamble = f"""You are responding as a {assigned_consultant['title']} - an unprecedented combination of industry-leading experts.

ULTRA-EXPERT PROFILE:
- Integrated Expertise: {assigned_consultant['expertise_count']} specialized domains
- Combined Experience: {assigned_consultant['total_experience_years']}+ years across multiple industries
- Integration Approach: Cross-domain synthesis with deep specialization
- Response Style: {assigned_consultant['style']}

DOMAIN INTEGRATION: {', '.join([f"{skill} ({weight:.1%})" for skill, weight in assigned_consultant['domain_integration']])}

SPECIALIZED EXPERTISE AREAS:
{chr(10).join([f"• {expertise}" for expertise in assigned_consultant['expertise'][:8]])}

ASSIGNMENT RATIONALE: {consultant_assignment['assignment_rationale']}

KNOWLEDGE DEPTH REQUIREMENT: 
- Provide insights equivalent to a visionary thought leader combining expertise from multiple domains
- Synthesize knowledge across {assigned_consultant['expertise_count']} specialization areas
- Apply interdisciplinary thinking and cross-domain innovation
- Leverage combined {assigned_consultant['total_experience_years']}+ years of integrated experience

ULTRA-EXPERT RESPONSE GUIDELINES:
- Draw from extensive cross-domain experience and pattern recognition
- Provide multi-perspective analysis combining different expert viewpoints
- Include interdisciplinary frameworks and innovative approaches
- Acknowledge complexity while providing actionable, synthesized recommendations
- Balance broad visionary thinking with deep domain-specific insights
- Use integrative problem-solving that spans multiple expertise areas
"""
        else:
            # Standard single expert preamble
            preamble = f"""You are responding as a {assigned_consultant['title']} with the following profile:

EXPERTISE PROFILE:
- Primary Expertise: {assigned_consultant['primary_expertise']}
- Core Skills: {', '.join(assigned_consultant['expertise'])}
- Background: {assigned_consultant['background']}
- Response Style: {assigned_consultant['style']}

ASSIGNMENT RATIONALE: {consultant_assignment['assignment_rationale']}

EXPERTISE WEIGHTS: {', '.join([f"{skill}: {weight:.1%}" for skill, weight in consultant_assignment['expertise_weights'].items()])}

"""
            
            if assigned_consultant.get('secondary_expertise'):
                preamble += f"SECONDARY EXPERTISE: {', '.join(assigned_consultant['secondary_expertise'])}\n"
            
            preamble += f"""
KNOWLEDGE DEPTH REQUIREMENT: Provide insights equivalent to a highly experienced, industry-leading {assigned_consultant['title']} with deep domain expertise and practical experience.

RESPONSE GUIDELINES:
- Draw from extensive practical experience in your field
- Provide industry-specific insights and best practices  
- Include relevant frameworks, methodologies, or tools
- Acknowledge complexity while remaining actionable
- Balance theoretical knowledge with real-world application
"""
        
        return preamble
    
    def _build_synthesis_prompt_with_expert(self, user_input: str, context: Dict[str, Any],
                                          agent_outputs: List[Dict[str, Any]], 
                                          expert_preamble: str,
                                          assigned_consultant: Dict[str, Any]) -> str:
        """Build synthesis prompt with expert consultant context"""
        
        # Build context section with summarization for long conversations
        context_section = self._build_context_section(context)
        
        # Build agent outputs section if any
        agent_outputs_section = ""
        if agent_outputs:
            # Handle both dict and list formats
            if isinstance(agent_outputs, dict):
                # Convert dict to list format
                outputs_list = []
                for task_name, result in agent_outputs.items():
                    if isinstance(result, dict):
                        outputs_list.append(result)
                    else:
                        # Wrap string/non-dict results in dict format
                        outputs_list.append({
                            'task': task_name,
                            'content': str(result),
                            'result': str(result)
                        })
                agent_outputs = outputs_list
            
            # Ensure it's a list now
            if isinstance(agent_outputs, list):
                agent_outputs_section = f"\n\nAgent Analysis Results:\n"
                for i, output in enumerate(agent_outputs, 1):
                    # Handle both dict and string outputs
                    if isinstance(output, dict):
                        output_text = output.get('content') or output.get('result') or output.get('final_response') or str(output)
                    else:
                        # If output is a string or other type
                        output_text = str(output)
                    agent_outputs_section += f"Agent {i}: {output_text}\n"
            else:
                # Fallback for unexpected types
                agent_outputs_section = f"\n\nAgent Analysis Results:\n{str(agent_outputs)}\n"
        
        # Construct full prompt
        prompt = f"""{expert_preamble}

User Question: {user_input}

{context_section}{agent_outputs_section}

Instructions: Provide a comprehensive, helpful response that directly addresses the question from your expert perspective. If there's conversation context, use it to answer the current question appropriately. Be detailed, informative, and leverage your specialized expertise in {assigned_consultant.get('primary_expertise', 'general consulting')}.

Response:"""
        
        return prompt
    
    def _build_context_section(self, context: Dict[str, Any]) -> str:
        """Build context section with summarization for long conversations
        
        Uses Context Manager structure:
        - combined_context: Pre-formatted context string (preferred)
        - interaction_contexts: List of interaction summaries with 'summary' and 'timestamp'
        - user_context: User persona summary string
        """
        if not context:
            return ""
        
        # Prefer combined_context if available (pre-formatted by Context Manager)
        # combined_context includes Session Context, User Context, and Interaction Contexts
        combined_context = context.get('combined_context', '')
        if combined_context:
            # Use the pre-formatted context from Context Manager
            # It already includes Session Context, User Context, and Interaction Contexts formatted
            return f"\n\nConversation Context:\n{combined_context}"
        
        # Fallback: Build from individual components if combined_context not available
        # All components are from cache
        session_context = context.get('session_context', {})
        session_summary = session_context.get('summary', '') if isinstance(session_context, dict) else ""
        interaction_contexts = context.get('interaction_contexts', [])
        user_context = context.get('user_context', '')
        
        context_section = ""
        
        # Add session context if available (from cache)
        if session_summary:
            context_section += f"\n\nSession Context (Session Summary):\n{session_summary[:500]}...\n"
        # Add user context if available
        if user_context:
            context_section += f"\n\nUser Context (Persona Summary):\n{user_context[:500]}...\n"
        
        # Add interaction contexts
        if interaction_contexts:
            if len(interaction_contexts) <= 8:
                # Show all interaction summaries for short conversations
                context_section += "\n\nPrevious Conversation Summary:\n"
                for i, ic in enumerate(interaction_contexts, 1):
                    summary = ic.get('summary', '')
                    if summary:
                        context_section += f"  {i}. {summary}\n"
            else:
                # Summarize older interactions, show recent ones
                recent_contexts = interaction_contexts[-8:]  # Last 8 interactions
                older_contexts = interaction_contexts[:-8]   # Everything before last 8
                
                # Create summary of older interactions
                summary = self._summarize_interaction_contexts(older_contexts)
                
                context_section += f"\n\nConversation Summary (earlier context):\n{summary}\n\nRecent Conversation:\n"
                
                for i, ic in enumerate(recent_contexts, 1):
                    summary_text = ic.get('summary', '')
                    if summary_text:
                        context_section += f"  {i}. {summary_text}\n"
        
        return context_section
    
    def _summarize_interaction_contexts(self, interaction_contexts: List[Dict[str, Any]]) -> str:
        """Summarize older interaction contexts to preserve key context
        
        Uses Context Manager structure where interaction_contexts contains:
        - summary: 50-token interaction summary string
        - timestamp: Interaction timestamp
        """
        if not interaction_contexts:
            return "No prior context."
        
        # Extract key topics and themes from summaries
        topics = []
        key_points = []
        
        for ic in interaction_contexts:
            summary = ic.get('summary', '')
            
            if summary:
                # Extract topics from summary (simple keyword extraction)
                # Summaries are already condensed, so extract meaningful terms
                words = summary.lower().split()
                key_terms = [word for word in words if len(word) > 4][:3]
                topics.extend(key_terms)
                
                # Use summary as key point (already a summary)
                key_points.append(summary[:150])
        
        # Build summary
        unique_topics = list(set(topics))[:5]  # Top 5 unique topics
        recent_points = key_points[-5:]  # Last 5 key points
        
        summary_text = f"Topics discussed: {', '.join(unique_topics) if unique_topics else 'General discussion'}\n"
        summary_text += f"Key points: {' | '.join(recent_points) if recent_points else 'No specific points'}"
        
        return summary_text
    
    def _summarize_interactions(self, interactions: List[Dict[str, Any]]) -> str:
        """Legacy method for backward compatibility - delegates to _summarize_interaction_contexts"""
        # Convert old format to new format if needed
        if interactions and 'summary' in interactions[0]:
            # Already in new format
            return self._summarize_interaction_contexts(interactions)
        else:
            # Old format - convert
            interaction_contexts = []
            for interaction in interactions:
                user_input = interaction.get('user_input', '')
                assistant_response = interaction.get('assistant_response') or interaction.get('response', '')
                # Create a simple summary
                summary = f"User asked: {user_input[:100]}..." if user_input else ""
                if summary:
                    interaction_contexts.append({'summary': summary})
            return self._summarize_interaction_contexts(interaction_contexts)
    
    def _extract_intent_info(self, agent_outputs: List[Dict[str, Any]]) -> Dict[str, Any]:
        """Extract intent information from agent outputs"""
        for output in agent_outputs:
            if 'primary_intent' in output:
                return {
                    'primary_intent': output['primary_intent'],
                    'confidence': output.get('confidence_scores', {}).get(output['primary_intent'], 0.5),
                    'source_agent': output.get('agent_id', 'unknown')
                }
        return None
    
    def _extract_source_references(self, agent_outputs: List[Dict[str, Any]]) -> List[str]:
        """Extract source references from agent outputs"""
        sources = []
        for output in agent_outputs:
            agent_id = output.get('agent_id', 'unknown')
            sources.append(agent_id)
        return list(set(sources))  # Remove duplicates
    
    def _calculate_quality_metrics(self, synthesis_result: Dict[str, Any]) -> Dict[str, Any]:
        """Calculate quality metrics for synthesis"""
        response = synthesis_result.get('final_response', '')
        
        return {
            "length": len(response),
            "word_count": len(response.split()) if response else 0,
            "coherence_score": synthesis_result.get('coherence_score', 0.7),
            "source_count": len(synthesis_result.get('source_references', [])),
            "has_structured_elements": bool(re.search(r'[•\d+\.]', response)) if response else False
        }
    
    def _check_intent_alignment(self, synthesis_result: Dict[str, Any], intent_info: Dict[str, Any]) -> Dict[str, Any]:
        """Check if synthesis aligns with detected intent"""
        # Calculate alignment based on intent confidence and response quality
        intent_confidence = intent_info.get('confidence', 0.5)
        coherence_score = synthesis_result.get('coherence_score', 0.7)
        # Alignment is average of intent confidence and coherence
        alignment_score = (intent_confidence + coherence_score) / 2.0
        
        return {
            "intent_detected": intent_info.get('primary_intent'),
            "alignment_score": alignment_score,
            "alignment_verified": alignment_score > 0.7
        }
    
    def _identify_improvements(self, response: str) -> List[str]:
        """Identify opportunities to improve the response"""
        improvements = []
        
        if len(response) < 50:
            improvements.append("Could be more detailed")
        
        if "?" not in response and len(response.split()) < 100:
            improvements.append("Consider adding examples")
        
        return improvements
    
    def _get_fallback_response(self, user_input: str, agent_outputs: List[Dict[str, Any]], 
                               assigned_consultant: Dict[str, Any]) -> Dict[str, Any]:
        """Provide fallback response when synthesis fails (LLM API failure only)"""
        # Only use fallback when LLM API actually fails - not as default
        if user_input:
            fallback_text = f"Thank you for your question: '{user_input}'. I'm processing your request and will provide a detailed response shortly."
        else:
            fallback_text = "I apologize, but I encountered an issue processing your request. Please try again."
        
        return {
            "synthesized_response": fallback_text,
            "draft_response": fallback_text,
            "final_response": fallback_text,
            "assigned_consultant": assigned_consultant,
            "source_references": self._extract_source_references(agent_outputs),
            "coherence_score": 0.5,
            "improvement_opportunities": ["LLM API error - fallback activated"],
            "synthesis_method": "expert_enhanced_fallback",
            "agent_id": self.agent_id,
            "synthesis_quality_metrics": self._calculate_quality_metrics({"final_response": fallback_text}),
            "error": True,
            "synthesis_metadata": {"expert_enhanced": True, "error": True, "llm_api_failed": True}
        }


# Backward compatibility: ResponseSynthesisAgent is now EnhancedSynthesisAgent
ResponseSynthesisAgent = EnhancedSynthesisAgent


# Factory function for compatibility
def create_synthesis_agent(llm_router) -> EnhancedSynthesisAgent:
    """Factory function to create enhanced synthesis agent"""
    return EnhancedSynthesisAgent(llm_router)