semantic_breed_recommender.py

import random
import hashlib
import numpy as np
import sqlite3
import re
import traceback
from typing import List, Dict, Tuple, Optional, Any
from dataclasses import dataclass
from sentence_transformers import SentenceTransformer
import torch
from sklearn.metrics.pairwise import cosine_similarity
from dog_database import get_dog_description
from breed_health_info import breed_health_info
from breed_noise_info import breed_noise_info
from scoring_calculation_system import UserPreferences, calculate_compatibility_score, UnifiedScoringSystem, calculate_unified_breed_scores
from query_understanding import QueryUnderstandingEngine, analyze_user_query
from constraint_manager import ConstraintManager, apply_breed_constraints
from multi_head_scorer import MultiHeadScorer, score_breed_candidates, BreedScore
from score_calibrator import ScoreCalibrator, calibrate_breed_scores
from config_manager import get_config_manager, get_standardized_breed_data

@dataclass
class BreedDescriptionVector:
    """Data structure for breed description vectorization"""
    breed_name: str
    description_text: str
    embedding: np.ndarray
    characteristics: Dict[str, Any]

class SemanticBreedRecommender:
    """
    Enhanced SBERT-based semantic breed recommendation system
    Provides multi-dimensional natural language understanding for dog breed recommendations
    """

    def __init__(self):
        """Initialize the semantic recommender"""
        self.model_name = 'all-MiniLM-L6-v2'  # Efficient SBERT model
        self.sbert_model = None
        self._sbert_loading_attempted = False
        self.breed_vectors = {}
        self.breed_list = self._get_breed_list()
        self.comparative_keywords = {
            'most': 1.0, 'love': 1.0, 'prefer': 0.9, 'like': 0.8,
            'then': 0.7, 'second': 0.7, 'followed': 0.6,
            'third': 0.5, 'least': 0.3, 'dislike': 0.2
        }
        # Defer SBERT model loading until needed in GPU context
        # This prevents CUDA initialization issues in ZeroGPU environment
        print("SemanticBreedRecommender initialized (SBERT loading deferred)")

        # Initialize multi-head scorer with SBERT model if enhanced mode is enabled
        # if self.sbert_model:
        #     self.multi_head_scorer = MultiHeadScorer(self.sbert_model)
        #     print("Multi-head scorer initialized with SBERT model")

    def _get_breed_list(self) -> List[str]:
        """Get breed list from database"""
        try:
            conn = sqlite3.connect('animal_detector.db')
            cursor = conn.cursor()
            cursor.execute("SELECT DISTINCT Breed FROM AnimalCatalog")
            breeds = [row[0] for row in cursor.fetchall()]
            cursor.close()
            conn.close()
            return breeds
        except Exception as e:
            print(f"Error getting breed list: {str(e)}")
            # Backup breed list for Google Colab environment
            return ['Labrador_Retriever', 'German_Shepherd', 'Golden_Retriever',
                   'Bulldog', 'Poodle', 'Beagle', 'Rottweiler', 'Yorkshire_Terrier']

    def _initialize_model(self):
        """Initialize SBERT model with fallback - designed for ZeroGPU compatibility"""
        if self.sbert_model is not None or self._sbert_loading_attempted:
            return self.sbert_model
            
        try:
            print("Loading SBERT model in GPU context...")
            # Try different model names if the primary one fails
            model_options = ['all-MiniLM-L6-v2', 'all-mpnet-base-v2', 'all-MiniLM-L12-v2']

            for model_name in model_options:
                try:
                    # Specify device explicitly to handle ZeroGPU environment
                    import torch
                    device = 'cuda' if torch.cuda.is_available() else 'cpu'
                    self.sbert_model = SentenceTransformer(model_name, device=device)
                    self.model_name = model_name
                    print(f"SBERT model {model_name} loaded successfully on {device}")
                    return self.sbert_model
                except Exception as model_e:
                    print(f"Failed to load {model_name}: {str(model_e)}")
                    continue

            # If all models fail
            print("All SBERT models failed to load. Using basic text matching fallback.")
            self.sbert_model = None
            return None

        except Exception as e:
            print(f"Failed to initialize any SBERT model: {str(e)}")
            print(traceback.format_exc())
            print("Will provide basic text-based recommendations without embeddings")
            self.sbert_model = None
            return None
        finally:
            self._sbert_loading_attempted = True

    def _create_breed_description(self, breed: str) -> str:
        """Create comprehensive natural language description for breed with all key characteristics"""
        try:
            # Get all information sources
            breed_info = get_dog_description(breed) or {}
            health_info = breed_health_info.get(breed, {}) if breed_health_info else {}
            noise_info = breed_noise_info.get(breed, {}) if breed_noise_info else {}

            breed_display_name = breed.replace('_', ' ')
            description_parts = []

            # 1. Basic size and physical characteristics
            size = breed_info.get('Size', 'medium').lower()
            description_parts.append(f"{breed_display_name} is a {size} sized dog breed")

            # 2. Temperament and personality (critical for matching)
            temperament = breed_info.get('Temperament', '')
            if temperament:
                description_parts.append(f"with a {temperament.lower()} temperament")

            # 3. Exercise and activity level (critical for apartment living)
            exercise_needs = breed_info.get('Exercise Needs', 'moderate').lower()
            if 'high' in exercise_needs or 'very high' in exercise_needs:
                description_parts.append("requiring high daily exercise and mental stimulation")
            elif 'low' in exercise_needs or 'minimal' in exercise_needs:
                description_parts.append("with minimal exercise requirements, suitable for apartment living")
            else:
                description_parts.append("with moderate exercise needs")

            # 4. Noise characteristics (critical for quiet requirements)
            noise_level = noise_info.get('noise_level', 'moderate').lower()
            if 'low' in noise_level or 'quiet' in noise_level:
                description_parts.append("known for being quiet and rarely barking")
            elif 'high' in noise_level or 'loud' in noise_level:
                description_parts.append("tends to be vocal and bark frequently")
            else:
                description_parts.append("with moderate barking tendencies")

            # 5. Living space compatibility
            if size in ['small', 'tiny']:
                description_parts.append("excellent for small apartments and limited spaces")
            elif size in ['large', 'giant']:
                description_parts.append("requiring large living spaces and preferably a yard")
            else:
                description_parts.append("adaptable to various living situations")

            # 6. Grooming and maintenance
            grooming_needs = breed_info.get('Grooming Needs', 'moderate').lower()
            if 'high' in grooming_needs:
                description_parts.append("requiring regular professional grooming")
            elif 'low' in grooming_needs:
                description_parts.append("with minimal grooming requirements")
            else:
                description_parts.append("with moderate grooming needs")

            # 7. Family compatibility
            good_with_children = breed_info.get('Good with Children', 'Yes')
            if good_with_children == 'Yes':
                description_parts.append("excellent with children and families")
            else:
                description_parts.append("better suited for adult households")

            # 8. Intelligence and trainability (from database description)
            intelligence_keywords = []
            description_text = breed_info.get('Description', '').lower()

            if description_text:
                # Extract intelligence indicators from description
                if any(word in description_text for word in ['intelligent', 'smart', 'clever', 'quick to learn']):
                    intelligence_keywords.extend(['highly intelligent', 'trainable', 'quick learner'])
                elif any(word in description_text for word in ['stubborn', 'independent', 'difficult to train']):
                    intelligence_keywords.extend(['independent minded', 'requires patience', 'challenging to train'])
                else:
                    intelligence_keywords.extend(['moderate intelligence', 'trainable with consistency'])

                # Extract working/purpose traits from description
                if any(word in description_text for word in ['working', 'herding', 'guard', 'hunting']):
                    intelligence_keywords.extend(['working breed', 'purpose-driven', 'task-oriented'])
                elif any(word in description_text for word in ['companion', 'lap', 'toy', 'decorative']):
                    intelligence_keywords.extend(['companion breed', 'affectionate', 'people-focused'])

                # Add intelligence context to description
                if intelligence_keywords:
                    description_parts.append(f"characterized as {', '.join(intelligence_keywords[:2])}")

            # 9. Special characteristics and purpose (enhanced with database mining)
            if breed_info.get('Description'):
                desc = breed_info.get('Description', '')[:150]  # Increased to 150 chars for more context
                if desc:
                    # Extract key traits from description for better semantic matching
                    desc_lower = desc.lower()
                    key_traits = []

                    # Extract key behavioral traits from description
                    if 'friendly' in desc_lower:
                        key_traits.append('friendly')
                    if 'gentle' in desc_lower:
                        key_traits.append('gentle')
                    if 'energetic' in desc_lower or 'active' in desc_lower:
                        key_traits.append('energetic')
                    if 'calm' in desc_lower or 'peaceful' in desc_lower:
                        key_traits.append('calm')
                    if 'protective' in desc_lower or 'guard' in desc_lower:
                        key_traits.append('protective')

                    trait_text = f" and {', '.join(key_traits)}" if key_traits else ""
                    description_parts.append(f"Known for: {desc.lower()}{trait_text}")

            # 9. Care level requirements
            try:
                care_level = breed_info.get('Care Level', 'moderate')
                if isinstance(care_level, str):
                    description_parts.append(f"requiring {care_level.lower()} overall care level")
                else:
                    description_parts.append("requiring moderate overall care level")
            except Exception as e:
                print(f"Error processing care level for {breed}: {str(e)}")
                description_parts.append("requiring moderate overall care level")

            # 10. Lifespan information
            try:
                lifespan = breed_info.get('Lifespan', '10-12 years')
                if lifespan and isinstance(lifespan, str) and lifespan.strip():
                    description_parts.append(f"with a typical lifespan of {lifespan}")
                else:
                    description_parts.append("with a typical lifespan of 10-12 years")
            except Exception as e:
                print(f"Error processing lifespan for {breed}: {str(e)}")
                description_parts.append("with a typical lifespan of 10-12 years")

            # Create comprehensive description
            full_description = '. '.join(description_parts) + '.'

            # Add comprehensive keywords for better semantic matching
            keywords = []

            # Basic breed name keywords
            keywords.extend([word.lower() for word in breed_display_name.split()])

            # Temperament keywords
            if temperament:
                keywords.extend([word.lower().strip(',') for word in temperament.split()])

            # Size-based keywords
            if 'small' in size or 'tiny' in size:
                keywords.extend(['small', 'tiny', 'compact', 'little', 'apartment', 'indoor', 'lap'])
            elif 'large' in size or 'giant' in size:
                keywords.extend(['large', 'big', 'giant', 'huge', 'yard', 'space', 'outdoor'])
            else:
                keywords.extend(['medium', 'moderate', 'average', 'balanced'])

            # Activity level keywords
            exercise_needs = breed_info.get('Exercise Needs', 'moderate').lower()
            if 'high' in exercise_needs:
                keywords.extend(['active', 'energetic', 'exercise', 'outdoor', 'hiking', 'running', 'athletic'])
            elif 'low' in exercise_needs:
                keywords.extend(['calm', 'low-energy', 'indoor', 'relaxed', 'couch', 'sedentary'])
            else:
                keywords.extend(['moderate', 'balanced', 'walks', 'regular'])

            # Noise level keywords
            noise_level = noise_info.get('noise_level', 'moderate').lower()
            if 'quiet' in noise_level or 'low' in noise_level:
                keywords.extend(['quiet', 'silent', 'calm', 'peaceful', 'low-noise'])
            elif 'high' in noise_level or 'loud' in noise_level:
                keywords.extend(['vocal', 'barking', 'loud', 'alert', 'watchdog'])

            # Living situation keywords
            if size in ['small', 'tiny'] and 'low' in exercise_needs:
                keywords.extend(['apartment', 'city', 'urban', 'small-space'])
            if size in ['large', 'giant'] or 'high' in exercise_needs:
                keywords.extend(['house', 'yard', 'suburban', 'rural', 'space'])

            # Family keywords
            good_with_children = breed_info.get('Good with Children', 'Yes')
            if good_with_children == 'Yes':
                keywords.extend(['family', 'children', 'kids', 'friendly', 'gentle'])

            # Intelligence and trainability keywords (from database description mining)
            if intelligence_keywords:
                keywords.extend([word.lower() for phrase in intelligence_keywords for word in phrase.split()])

            # Grooming-based keywords (enhanced)
            grooming_needs = breed_info.get('Grooming Needs', 'moderate').lower()
            if 'high' in grooming_needs:
                keywords.extend(['high-maintenance', 'professional-grooming', 'daily-brushing', 'coat-care'])
            elif 'low' in grooming_needs:
                keywords.extend(['low-maintenance', 'minimal-grooming', 'easy-care', 'wash-and-go'])
            else:
                keywords.extend(['moderate-grooming', 'weekly-brushing', 'regular-care'])

            # Lifespan-based keywords
            lifespan = breed_info.get('Lifespan', '10-12 years')
            if lifespan and isinstance(lifespan, str):
                try:
                    # Extract years from lifespan string (e.g., "10-12 years" or "12-15 years")
                    import re
                    years = re.findall(r'\d+', lifespan)
                    if years:
                        avg_years = sum(int(y) for y in years) / len(years)
                        if avg_years >= 14:
                            keywords.extend(['long-lived', 'longevity', 'durable', 'healthy-lifespan'])
                        elif avg_years <= 8:
                            keywords.extend(['shorter-lifespan', 'health-considerations', 'special-care'])
                        else:
                            keywords.extend(['average-lifespan', 'moderate-longevity'])
                except:
                    keywords.extend(['average-lifespan'])

            # Add keywords to description for better semantic matching
            unique_keywords = list(set(keywords))
            keyword_text = ' '.join(unique_keywords)
            full_description += f" Additional context: {keyword_text}"

            return full_description

        except Exception as e:
            print(f"Error creating description for {breed}: {str(e)}")
            return f"{breed.replace('_', ' ')} is a dog breed with unique characteristics."

    def _build_breed_vectors(self):
        """Build vector representations for all breeds - called lazily when needed"""
        try:
            print("Building breed vector database...")

            # Initialize model if not already done
            if self.sbert_model is None:
                self._initialize_model()
                
            # Skip if model is not available
            if self.sbert_model is None:
                print("SBERT model not available, skipping vector building")
                return

            for breed in self.breed_list:
                description = self._create_breed_description(breed)

                # Generate embedding vector
                embedding = self.sbert_model.encode(description, convert_to_tensor=False)

                # Get breed characteristics
                breed_info = get_dog_description(breed)
                characteristics = {
                    'size': breed_info.get('Size', 'Medium') if breed_info else 'Medium',
                    'exercise_needs': breed_info.get('Exercise Needs', 'Moderate') if breed_info else 'Moderate',
                    'grooming_needs': breed_info.get('Grooming Needs', 'Moderate') if breed_info else 'Moderate',
                    'good_with_children': breed_info.get('Good with Children', 'Yes') if breed_info else 'Yes',
                    'temperament': breed_info.get('Temperament', '') if breed_info else ''
                }

                self.breed_vectors[breed] = BreedDescriptionVector(
                    breed_name=breed,
                    description_text=description,
                    embedding=embedding,
                    characteristics=characteristics
                )

            print(f"Successfully built {len(self.breed_vectors)} breed vectors")

        except Exception as e:
            print(f"Error building breed vectors: {str(e)}")
            print(traceback.format_exc())
            raise

    def _parse_comparative_preferences(self, user_input: str) -> Dict[str, float]:
        """Parse comparative preference expressions"""
        breed_scores = {}

        # Normalize input
        text = user_input.lower()

        # Find breed names and preference keywords
        for breed in self.breed_list:
            breed_display = breed.replace('_', ' ').lower()
            breed_words = breed_display.split()

            # Check if this breed is mentioned
            breed_mentioned = False
            for word in breed_words:
                if word in text:
                    breed_mentioned = True
                    break

            if breed_mentioned:
                # Find nearby preference keywords
                breed_score = 0.5  # Default score

                # Look for keywords within 50 characters of breed name
                breed_pos = text.find(breed_words[0])
                if breed_pos != -1:
                    # Check for keywords in context
                    context_start = max(0, breed_pos - 50)
                    context_end = min(len(text), breed_pos + 50)
                    context = text[context_start:context_end]

                    for keyword, score in self.comparative_keywords.items():
                        if keyword in context:
                            breed_score = max(breed_score, score)

                breed_scores[breed] = breed_score

        return breed_scores

    def _extract_lifestyle_keywords(self, user_input: str) -> Dict[str, List[str]]:
        """Enhanced lifestyle keyword extraction with better pattern matching"""
        keywords = {
            'living_space': [],
            'activity_level': [],
            'family_situation': [],
            'noise_preference': [],
            'size_preference': [],
            'care_level': [],
            'special_needs': [],
            'intelligence_preference': [],
            'grooming_preference': [],
            'lifespan_preference': [],
            'temperament_preference': [],
            'experience_level': []
        }

        text = user_input.lower()

        # Enhanced living space detection
        apartment_terms = ['apartment', 'flat', 'condo', 'small space', 'city living', 'urban', 'no yard', 'indoor']
        house_terms = ['house', 'yard', 'garden', 'backyard', 'large space', 'suburban', 'rural', 'farm']

        if any(term in text for term in apartment_terms):
            keywords['living_space'].append('apartment')
        if any(term in text for term in house_terms):
            keywords['living_space'].append('house')

        # Enhanced activity level detection
        high_activity = ['active', 'energetic', 'exercise', 'hiking', 'running', 'outdoor', 'sports', 'jogging',
                        'athletic', 'adventure', 'vigorous', 'high energy', 'workout']
        low_activity = ['calm', 'lazy', 'indoor', 'low energy', 'couch', 'sedentary', 'relaxed',
                       'peaceful', 'quiet lifestyle', 'minimal exercise']
        moderate_activity = ['moderate', 'walk', 'daily walks', 'light exercise']

        if any(term in text for term in high_activity):
            keywords['activity_level'].append('high')
        if any(term in text for term in low_activity):
            keywords['activity_level'].append('low')
        if any(term in text for term in moderate_activity):
            keywords['activity_level'].append('moderate')

        # Enhanced family situation detection
        children_terms = ['children', 'kids', 'family', 'child', 'toddler', 'baby', 'teenage', 'school age']
        elderly_terms = ['elderly', 'senior', 'old', 'retirement', 'aged', 'mature']
        single_terms = ['single', 'alone', 'individual', 'solo', 'myself']

        if any(term in text for term in children_terms):
            keywords['family_situation'].append('children')
        if any(term in text for term in elderly_terms):
            keywords['family_situation'].append('elderly')
        if any(term in text for term in single_terms):
            keywords['family_situation'].append('single')

        # Enhanced noise preference detection
        quiet_terms = ['quiet', 'silent', 'noise-sensitive', 'peaceful', 'no barking', 'minimal noise',
                      'soft-spoken', 'calm', 'tranquil']
        noise_ok_terms = ['loud', 'barking ok', 'noise tolerant', 'vocal', 'doesn\'t matter']

        if any(term in text for term in quiet_terms):
            keywords['noise_preference'].append('low')
        if any(term in text for term in noise_ok_terms):
            keywords['noise_preference'].append('high')

        # Enhanced size preference detection
        small_terms = ['small', 'tiny', 'little', 'compact', 'miniature', 'toy', 'lap dog']
        large_terms = ['large', 'big', 'giant', 'huge', 'massive', 'great']
        medium_terms = ['medium', 'moderate size', 'average', 'mid-sized']

        if any(term in text for term in small_terms):
            keywords['size_preference'].append('small')
        if any(term in text for term in large_terms):
            keywords['size_preference'].append('large')
        if any(term in text for term in medium_terms):
            keywords['size_preference'].append('medium')

        # Enhanced care level detection
        low_care = ['low maintenance', 'easy care', 'simple', 'minimal grooming', 'wash and go']
        high_care = ['high maintenance', 'grooming', 'care intensive', 'professional grooming', 'daily brushing']

        if any(term in text for term in low_care):
            keywords['care_level'].append('low')
        if any(term in text for term in high_care):
            keywords['care_level'].append('high')

        # Intelligence preference detection (NEW)
        smart_terms = ['smart', 'intelligent', 'clever', 'bright', 'quick learner', 'easy to train', 'trainable', 'genius', 'brilliant']
        independent_terms = ['independent', 'stubborn', 'strong-willed', 'less trainable', 'thinks for themselves']

        if any(term in text for term in smart_terms):
            keywords['intelligence_preference'].append('high')
        if any(term in text for term in independent_terms):
            keywords['intelligence_preference'].append('independent')

        # Grooming preference detection (NEW)
        low_grooming_terms = ['low grooming', 'minimal grooming', 'easy care', 'wash and wear', 'no grooming', 'simple coat']
        high_grooming_terms = ['high grooming', 'professional grooming', 'lots of care', 'high maintenance coat', 'daily brushing', 'regular grooming']

        if any(term in text for term in low_grooming_terms):
            keywords['grooming_preference'].append('low')
        if any(term in text for term in high_grooming_terms):
            keywords['grooming_preference'].append('high')

        # Lifespan preference detection (NEW)
        long_lived_terms = ['long lived', 'long lifespan', 'live long', 'many years', '15+ years', 'longevity']
        healthy_terms = ['healthy breed', 'few health issues', 'robust', 'hardy', 'strong constitution']

        if any(term in text for term in long_lived_terms):
            keywords['lifespan_preference'].append('long')
        if any(term in text for term in healthy_terms):
            keywords['lifespan_preference'].append('healthy')

        # Temperament preference detection (NEW)
        gentle_terms = ['gentle', 'calm', 'peaceful', 'laid back', 'chill', 'mellow', 'docile']
        playful_terms = ['playful', 'energetic', 'fun', 'active personality', 'lively', 'spirited', 'bouncy']
        protective_terms = ['protective', 'guard', 'watchdog', 'alert', 'vigilant', 'defensive']
        friendly_terms = ['friendly', 'social', 'outgoing', 'loves people', 'sociable', 'gregarious']

        if any(term in text for term in gentle_terms):
            keywords['temperament_preference'].append('gentle')
        if any(term in text for term in playful_terms):
            keywords['temperament_preference'].append('playful')
        if any(term in text for term in protective_terms):
            keywords['temperament_preference'].append('protective')
        if any(term in text for term in friendly_terms):
            keywords['temperament_preference'].append('friendly')

        # Experience level detection (NEW)
        beginner_terms = ['first time', 'beginner', 'new to dogs', 'never had', 'novice', 'inexperienced']
        advanced_terms = ['experienced', 'advanced', 'dog expert', 'many dogs before', 'professional', 'seasoned']

        if any(term in text for term in beginner_terms):
            keywords['experience_level'].append('beginner')
        if any(term in text for term in advanced_terms):
            keywords['experience_level'].append('advanced')

        # Enhanced special needs detection
        guard_terms = ['guard', 'protection', 'security', 'watchdog', 'protective', 'defender']
        companion_terms = ['therapy', 'emotional support', 'companion', 'comfort', 'lap dog', 'cuddly']
        hypoallergenic_terms = ['hypoallergenic', 'allergies', 'non-shedding', 'allergy-friendly', 'no shed']
        multi_pet_terms = ['good with cats', 'cat friendly', 'multi-pet', 'other animals']

        if any(term in text for term in guard_terms):
            keywords['special_needs'].append('guard')
        if any(term in text for term in companion_terms):
            keywords['special_needs'].append('companion')
        if any(term in text for term in hypoallergenic_terms):
            keywords['special_needs'].append('hypoallergenic')
        if any(term in text for term in multi_pet_terms):
            keywords['special_needs'].append('multi_pet')

        return keywords

    def _apply_size_distribution_correction(self, recommendations: List[Dict]) -> List[Dict]:
        """Apply size distribution correction to prevent large breed bias"""
        if len(recommendations) < 10:
            return recommendations

        # Analyze size distribution
        size_counts = {'toy': 0, 'small': 0, 'medium': 0, 'large': 0, 'giant': 0}

        for rec in recommendations:
            breed_info = get_dog_description(rec['breed'])
            if breed_info:
                size = self._normalize_breed_size(breed_info.get('Size', 'Medium'))
                size_counts[size] += 1

        total_recs = len(recommendations)
        large_giant_ratio = (size_counts['large'] + size_counts['giant']) / total_recs

        # If more than 70% are large/giant breeds, apply correction
        if large_giant_ratio > 0.7:
            corrected_recommendations = []
            size_quotas = {'toy': 2, 'small': 4, 'medium': 6, 'large': 2, 'giant': 1}
            current_counts = {'toy': 0, 'small': 0, 'medium': 0, 'large': 0, 'giant': 0}

            # First pass: add breeds within quotas
            for rec in recommendations:
                breed_info = get_dog_description(rec['breed'])
                if breed_info:
                    size = self._normalize_breed_size(breed_info.get('Size', 'Medium'))
                    if current_counts[size] < size_quotas[size]:
                        corrected_recommendations.append(rec)
                        current_counts[size] += 1

            # Second pass: fill remaining slots with best remaining candidates
            remaining_slots = 15 - len(corrected_recommendations)
            remaining_breeds = [rec for rec in recommendations if rec not in corrected_recommendations]

            corrected_recommendations.extend(remaining_breeds[:remaining_slots])
            return corrected_recommendations

        return recommendations

    def _normalize_breed_size(self, size: str) -> str:
        """Normalize breed size to standard categories"""
        if not isinstance(size, str):
            return 'medium'

        size_lower = size.lower()
        if any(term in size_lower for term in ['toy', 'tiny']):
            return 'toy'
        elif 'small' in size_lower:
            return 'small'
        elif 'medium' in size_lower:
            return 'medium'
        elif 'large' in size_lower:
            return 'large'
        elif any(term in size_lower for term in ['giant', 'extra large']):
            return 'giant'
        else:
            return 'medium'

    def _parse_user_requirements(self, user_input: str) -> Dict[str, Any]:
        """Parse user requirements more accurately"""
        requirements = {
            'living_space': None,
            'exercise_level': None,
            'preferred_size': None,
            'noise_tolerance': None
        }

        input_lower = user_input.lower()

        # Living space detection
        if 'apartment' in input_lower or 'small' in input_lower:
            requirements['living_space'] = 'apartment'
        elif 'large house' in input_lower or 'big' in input_lower:
            requirements['living_space'] = 'large_house'
        elif 'medium' in input_lower:
            requirements['living_space'] = 'medium_house'

        # Exercise level detection
        if "don't exercise" in input_lower or 'low exercise' in input_lower:
            requirements['exercise_level'] = 'low'
        elif any(term in input_lower for term in ['hiking', 'running', 'active']):
            requirements['exercise_level'] = 'high'
        elif '30 minutes' in input_lower or 'moderate' in input_lower:
            requirements['exercise_level'] = 'moderate'

        # Size preference detection
        if any(term in input_lower for term in ['small dog', 'tiny', 'toy']):
            requirements['preferred_size'] = 'small'
        elif any(term in input_lower for term in ['large dog', 'big dog']):
            requirements['preferred_size'] = 'large'
        elif 'medium' in input_lower:
            requirements['preferred_size'] = 'medium'

        return requirements

    def _apply_hard_constraints(self, breed: str, user_input: str, breed_characteristics: Dict[str, Any]) -> float:
        """Enhanced hard constraints with stricter penalties"""
        penalty = 0.0
        user_text_lower = user_input.lower()

        # Get breed information
        breed_info = get_dog_description(breed)
        if not breed_info:
            return 0.0

        breed_size = breed_info.get('Size', '').lower()
        exercise_needs = breed_info.get('Exercise Needs', '').lower()

        # Apartment living constraints - MUCH STRICTER
        if any(term in user_text_lower for term in ['apartment', 'flat', 'studio', 'small space']):
            if 'giant' in breed_size:
                return -2.0  # Complete elimination
            elif 'large' in breed_size:
                if any(term in exercise_needs for term in ['high', 'very high']):
                    return -2.0  # Complete elimination
                else:
                    penalty -= 0.5  # Still significant penalty
            elif 'medium' in breed_size and 'very high' in exercise_needs:
                penalty -= 0.6

        # Exercise mismatch constraints
        if "don't exercise much" in user_text_lower or "low exercise" in user_text_lower:
            if any(term in exercise_needs for term in ['very high', 'extreme', 'intense']):
                return -2.0  # Complete elimination
            elif 'high' in exercise_needs:
                penalty -= 0.8

        # Moderate lifestyle detection
        if any(term in user_text_lower for term in ['moderate', 'balanced', '30 minutes', 'half hour']):
            # Penalize extremes
            if 'giant' in breed_size:
                penalty -= 0.7  # Strong penalty for giants
            elif 'very high' in exercise_needs:
                penalty -= 0.5

        # Children safety (existing logic remains but enhanced)
        if any(term in user_text_lower for term in ['child', 'kids', 'family', 'baby']):
            good_with_children = breed_info.get('Good with Children', '').lower()
            if good_with_children == 'no':
                return -2.0  # Complete elimination for safety

        return penalty

    def get_enhanced_semantic_recommendations(self, user_input: str, top_k: int = 15) -> List[Dict[str, Any]]:
        """
        Enhanced multi-dimensional semantic breed recommendation

        Args:
            user_input: User's natural language description
            top_k: Number of recommendations to return

        Returns:
            List of recommended breeds with enhanced scoring
        """
        try:
            # Stage 1: Query Understanding
            dimensions = self.query_engine.analyze_query(user_input)
            print(f"Query dimensions detected: {len(dimensions.spatial_constraints + dimensions.activity_level + dimensions.noise_preferences + dimensions.size_preferences + dimensions.family_context + dimensions.maintenance_level + dimensions.special_requirements)} total dimensions")

            # Stage 2: Apply Constraints
            filter_result = self.constraint_manager.apply_constraints(dimensions, min_candidates=max(8, top_k))
            print(f"Constraint filtering: {len(self.breed_list)} -> {len(filter_result.passed_breeds)} candidates")

            if not filter_result.passed_breeds:
                error_msg = f"No dog breeds match your requirements after applying constraints. Applied constraints: {filter_result.applied_constraints}. Consider relaxing some requirements."
                print(f"ERROR: {error_msg}")
                raise ValueError(error_msg)

            # Stage 3: Multi-head Scoring
            if self.multi_head_scorer:
                breed_scores = self.multi_head_scorer.score_breeds(filter_result.passed_breeds, dimensions)
                print(f"Multi-head scoring completed for {len(breed_scores)} breeds")
            else:
                print("Multi-head scorer not available, using fallback scoring")
                return self.get_semantic_recommendations(user_input, top_k)

            # Stage 4: Score Calibration
            breed_score_tuples = [(score.breed_name, score.final_score) for score in breed_scores]
            calibration_result = self.score_calibrator.calibrate_scores(breed_score_tuples)
            print(f"Score calibration: method={calibration_result.calibration_method}")

            # Stage 5: Generate Final Recommendations
            final_recommendations = []

            for i, breed_score in enumerate(breed_scores[:top_k]):
                breed_name = breed_score.breed_name

                # Get calibrated score
                calibrated_score = calibration_result.score_mapping.get(breed_name, breed_score.final_score)

                # Get standardized breed info
                standardized_info = get_standardized_breed_data(breed_name.replace(' ', '_'))
                if standardized_info:
                    breed_info = self._get_breed_info_from_standardized(standardized_info)
                else:
                    breed_info = get_dog_description(breed_name.replace(' ', '_')) or {}

                recommendation = {
                    'breed': breed_name,
                    'rank': i + 1,
                    'overall_score': calibrated_score,
                    'final_score': calibrated_score,
                    'semantic_score': breed_score.semantic_component,
                    'attribute_score': breed_score.attribute_component,
                    'bidirectional_bonus': breed_score.bidirectional_bonus,
                    'confidence_score': breed_score.confidence_score,
                    'dimensional_breakdown': breed_score.dimensional_breakdown,
                    'explanation': breed_score.explanation,
                    'size': breed_info.get('Size', 'Unknown'),
                    'temperament': breed_info.get('Temperament', ''),
                    'exercise_needs': breed_info.get('Exercise Needs', 'Moderate'),
                    'grooming_needs': breed_info.get('Grooming Needs', 'Moderate'),
                    'good_with_children': breed_info.get('Good with Children', 'Yes'),
                    'lifespan': breed_info.get('Lifespan', '10-12 years'),
                    'description': breed_info.get('Description', ''),
                    'search_type': 'enhanced_description',
                    'calibration_method': calibration_result.calibration_method,
                    'applied_constraints': filter_result.applied_constraints,
                    'relaxed_constraints': filter_result.relaxed_constraints,
                    'warnings': filter_result.warnings
                }

                final_recommendations.append(recommendation)

            # Apply size distribution correction before returning
            corrected_recommendations = self._apply_size_distribution_correction(final_recommendations)

            # Stage 6: Apply Intelligent Trait Matching Enhancement
            intelligence_enhanced_recommendations = self._apply_intelligent_trait_matching(corrected_recommendations, user_input)

            print(f"Generated {len(intelligence_enhanced_recommendations)} enhanced semantic recommendations with intelligent trait matching")
            return intelligence_enhanced_recommendations

        except Exception as e:
            print(f"Error in enhanced semantic recommendations: {str(e)}")
            print(traceback.format_exc())
            # Fallback to original method
            return self.get_semantic_recommendations(user_input, top_k)

    def _apply_intelligent_trait_matching(self, recommendations: List[Dict], user_input: str) -> List[Dict]:
        """Apply intelligent trait matching based on enhanced keyword extraction and database mining"""
        try:
            # Extract enhanced keywords from user input
            extracted_keywords = self._extract_lifestyle_keywords(user_input)

            # Apply intelligent trait matching to each recommendation
            enhanced_recommendations = []

            for rec in recommendations:
                breed_name = rec['breed'].replace(' ', '_')

                # Get breed database information
                breed_info = get_dog_description(breed_name) or {}

                # Calculate intelligent trait bonuses
                intelligence_bonus = 0.0
                trait_match_details = {}

                # 1. Intelligence Matching
                if extracted_keywords.get('intelligence_preference'):
                    intelligence_pref = extracted_keywords['intelligence_preference'][0]
                    breed_desc = breed_info.get('Description', '').lower()

                    if intelligence_pref == 'high':
                        if any(word in breed_desc for word in ['intelligent', 'smart', 'clever', 'quick to learn', 'trainable']):
                            intelligence_bonus += 0.05
                            trait_match_details['intelligence_match'] = 'High intelligence match detected'
                        elif any(word in breed_desc for word in ['stubborn', 'independent', 'difficult']):
                            intelligence_bonus -= 0.02
                            trait_match_details['intelligence_warning'] = 'May be challenging to train'

                    elif intelligence_pref == 'independent':
                        if any(word in breed_desc for word in ['independent', 'stubborn', 'strong-willed']):
                            intelligence_bonus += 0.03
                            trait_match_details['independence_match'] = 'Independent nature match'

                # 2. Grooming Preference Matching
                if extracted_keywords.get('grooming_preference'):
                    grooming_pref = extracted_keywords['grooming_preference'][0]
                    breed_grooming = breed_info.get('Grooming Needs', '').lower()

                    if grooming_pref == 'low' and 'low' in breed_grooming:
                        intelligence_bonus += 0.03
                        trait_match_details['grooming_match'] = 'Low maintenance grooming match'
                    elif grooming_pref == 'high' and 'high' in breed_grooming:
                        intelligence_bonus += 0.03
                        trait_match_details['grooming_match'] = 'High maintenance grooming match'
                    elif grooming_pref == 'low' and 'high' in breed_grooming:
                        intelligence_bonus -= 0.04
                        trait_match_details['grooming_mismatch'] = 'High grooming needs may not suit preferences'

                # 3. Temperament Preference Matching
                if extracted_keywords.get('temperament_preference'):
                    temp_prefs = extracted_keywords['temperament_preference']
                    breed_temperament = breed_info.get('Temperament', '').lower()
                    breed_desc = breed_info.get('Description', '').lower()

                    temp_text = (breed_temperament + ' ' + breed_desc).lower()

                    for temp_pref in temp_prefs:
                        if temp_pref == 'gentle' and any(word in temp_text for word in ['gentle', 'calm', 'peaceful', 'mild']):
                            intelligence_bonus += 0.04
                            trait_match_details['temperament_match'] = f'Gentle temperament match: {temp_pref}'
                        elif temp_pref == 'playful' and any(word in temp_text for word in ['playful', 'energetic', 'lively', 'fun']):
                            intelligence_bonus += 0.04
                            trait_match_details['temperament_match'] = f'Playful temperament match: {temp_pref}'
                        elif temp_pref == 'protective' and any(word in temp_text for word in ['protective', 'guard', 'alert', 'watchful']):
                            intelligence_bonus += 0.04
                            trait_match_details['temperament_match'] = f'Protective temperament match: {temp_pref}'
                        elif temp_pref == 'friendly' and any(word in temp_text for word in ['friendly', 'social', 'outgoing', 'people']):
                            intelligence_bonus += 0.04
                            trait_match_details['temperament_match'] = f'Friendly temperament match: {temp_pref}'

                # 4. Experience Level Matching
                if extracted_keywords.get('experience_level'):
                    exp_level = extracted_keywords['experience_level'][0]
                    breed_desc = breed_info.get('Description', '').lower()

                    if exp_level == 'beginner':
                        # Favor easy-to-handle breeds for beginners
                        if any(word in breed_desc for word in ['easy', 'gentle', 'good for beginners', 'family', 'calm']):
                            intelligence_bonus += 0.06
                            trait_match_details['beginner_friendly'] = 'Good choice for first-time owners'
                        elif any(word in breed_desc for word in ['challenging', 'dominant', 'requires experience', 'strong-willed']):
                            intelligence_bonus -= 0.08
                            trait_match_details['experience_warning'] = 'May be challenging for first-time owners'

                    elif exp_level == 'advanced':
                        # Advanced users can handle more challenging breeds
                        if any(word in breed_desc for word in ['working', 'requires experience', 'intelligent', 'strong']):
                            intelligence_bonus += 0.03
                            trait_match_details['advanced_suitable'] = 'Good match for experienced owners'

                # 5. Lifespan Preference Matching
                if extracted_keywords.get('lifespan_preference'):
                    lifespan_pref = extracted_keywords['lifespan_preference'][0]
                    breed_lifespan = breed_info.get('Lifespan', '10-12 years')

                    try:
                        import re
                        years = re.findall(r'\d+', breed_lifespan)
                        if years:
                            avg_years = sum(int(y) for y in years) / len(years)
                            if lifespan_pref == 'long' and avg_years >= 13:
                                intelligence_bonus += 0.02
                                trait_match_details['longevity_match'] = f'Long lifespan match: {breed_lifespan}'
                            elif lifespan_pref == 'healthy' and avg_years >= 12:
                                intelligence_bonus += 0.02
                                trait_match_details['health_match'] = f'Healthy lifespan: {breed_lifespan}'
                    except:
                        pass

                # Apply the intelligence bonus to the overall score
                original_score = rec['overall_score']
                enhanced_score = min(1.0, original_score + intelligence_bonus)

                # Create enhanced recommendation with trait matching details
                enhanced_rec = rec.copy()
                enhanced_rec['overall_score'] = enhanced_score
                enhanced_rec['intelligence_bonus'] = intelligence_bonus
                enhanced_rec['trait_match_details'] = trait_match_details

                # Add detailed explanation if significant enhancement occurred
                if abs(intelligence_bonus) > 0.02:
                    enhancement_explanation = []
                    for detail_key, detail_value in trait_match_details.items():
                        enhancement_explanation.append(detail_value)

                    if enhancement_explanation:
                        current_explanation = enhanced_rec.get('explanation', '')
                        enhanced_explanation = current_explanation + f" Enhanced matching: {'; '.join(enhancement_explanation)}"
                        enhanced_rec['explanation'] = enhanced_explanation

                enhanced_recommendations.append(enhanced_rec)

            # Re-sort by enhanced overall score
            enhanced_recommendations.sort(key=lambda x: x['overall_score'], reverse=True)

            # Update ranks
            for i, rec in enumerate(enhanced_recommendations):
                rec['rank'] = i + 1

            print(f"Applied intelligent trait matching with average bonus: {sum(r['intelligence_bonus'] for r in enhanced_recommendations) / len(enhanced_recommendations):.3f}")

            return enhanced_recommendations

        except Exception as e:
            print(f"Error in intelligent trait matching: {str(e)}")
            # Return original recommendations if trait matching fails
            return recommendations

    def get_semantic_recommendations(self, user_input: str, top_k: int = 15) -> List[Dict[str, Any]]:
        """
        Get breed recommendations based on natural language description

        Args:
            user_input: User's natural language description
            top_k: Number of recommendations to return

        Returns:
            List of recommended breeds
        """
        try:
            print(f"Processing user input: {user_input}")

            # 嘗試載入SBERT模型（如果尚未載入）
            if self.sbert_model is None:
                self._initialize_model()
                
            # Check if model is available - if not, raise error
            if self.sbert_model is None:
                error_msg = "SBERT model not available. This could be due to:\n• Model download failed\n• Insufficient memory\n• Network connectivity issues\n\nPlease check your environment and try again."
                print(f"ERROR: {error_msg}")
                raise RuntimeError(error_msg)

            # 確保breed vectors已建構
            if not self.breed_vectors:
                self._build_breed_vectors()

            # Generate user input embedding
            user_embedding = self.sbert_model.encode(user_input, convert_to_tensor=False)

            # Parse comparative preferences
            comparative_prefs = self._parse_comparative_preferences(user_input)

            # Extract lifestyle keywords
            lifestyle_keywords = self._extract_lifestyle_keywords(user_input)

            # Calculate similarity with all breeds and apply constraints
            similarities = []

            for breed, breed_vector in self.breed_vectors.items():
                # Apply hard constraints first
                constraint_penalty = self._apply_hard_constraints(breed, user_input, breed_vector.characteristics)

                # Skip breeds that violate critical constraints
                if constraint_penalty <= -1.0:  # Complete disqualification
                    continue

                # Basic semantic similarity
                semantic_score = cosine_similarity(
                    [user_embedding],
                    [breed_vector.embedding]
                )[0][0]

                # Comparative preference weighting
                comparative_bonus = comparative_prefs.get(breed, 0.0)

                # Lifestyle matching bonus
                lifestyle_bonus = self._calculate_lifestyle_bonus(
                    breed_vector.characteristics,
                    lifestyle_keywords
                )

                # Apply constraint penalties
                lifestyle_bonus += constraint_penalty

                # Enhanced combined score with better distribution
                # Apply exponential scaling to create more natural score spread
                base_semantic = semantic_score ** 0.8  # Slightly compress high scores
                enhanced_lifestyle = lifestyle_bonus * 2.0  # Amplify lifestyle matching
                enhanced_comparative = comparative_bonus * 1.5  # Amplify breed preferences

                final_score = (
                    base_semantic * 0.55 +
                    enhanced_comparative * 0.30 +
                    enhanced_lifestyle * 0.15
                )

                # Add small random variation to break ties naturally
                random.seed(hash(breed))  # Consistent for same breed
                final_score += random.uniform(-0.03, 0.03)

                # Ensure final score doesn't exceed 1.0
                final_score = min(1.0, final_score)

                similarities.append({
                    'breed': breed,
                    'score': final_score,
                    'semantic_score': semantic_score,
                    'comparative_bonus': comparative_bonus,
                    'lifestyle_bonus': lifestyle_bonus
                })

            # Calculate standardized display scores with balanced distribution
            breed_display_scores = []

            # First, collect all semantic scores for normalization
            all_semantic_scores = [breed_data['semantic_score'] for breed_data in similarities]
            semantic_mean = np.mean(all_semantic_scores)
            semantic_std = np.std(all_semantic_scores) if len(all_semantic_scores) > 1 else 1.0

            for breed_data in similarities:
                breed = breed_data['breed']
                base_semantic = breed_data['semantic_score']

                # Normalize semantic score to prevent extreme outliers
                if semantic_std > 0:
                    normalized_semantic = (base_semantic - semantic_mean) / semantic_std
                    normalized_semantic = max(-2.0, min(2.0, normalized_semantic))  # Cap at 2 standard deviations
                    scaled_semantic = 0.5 + (normalized_semantic * 0.1)  # Map to 0.3-0.7 range
                else:
                    scaled_semantic = 0.5

                # Get breed characteristics
                breed_info = get_dog_description(breed) if breed != 'Unknown' else {}
                breed_size = breed_info.get('Size', '').lower() if breed_info else ''
                exercise_needs = breed_info.get('Exercise Needs', '').lower() if breed_info else ''

                # Calculate feature matching score (more important than pure semantic similarity)
                feature_score = 0.0
                user_text = user_input.lower()

                # Size and space requirements (high weight)
                if any(term in user_text for term in ['apartment', 'small', 'limited space']):
                    if 'small' in breed_size:
                        feature_score += 0.25
                    elif 'medium' in breed_size:
                        feature_score += 0.05
                    elif 'large' in breed_size or 'giant' in breed_size:
                        feature_score -= 0.30

                # Exercise requirements (high weight)
                if any(term in user_text for term in ['low exercise', 'minimal exercise', "doesn't need", 'not much']):
                    if 'low' in exercise_needs or 'minimal' in exercise_needs:
                        feature_score += 0.20
                    elif 'high' in exercise_needs or 'very high' in exercise_needs:
                        feature_score -= 0.25
                elif any(term in user_text for term in ['active', 'high exercise', 'running', 'hiking']):
                    if 'high' in exercise_needs:
                        feature_score += 0.20
                    elif 'low' in exercise_needs:
                        feature_score -= 0.15

                # Family compatibility
                if any(term in user_text for term in ['children', 'kids', 'family']):
                    good_with_children = breed_info.get('Good with Children', '') if breed_info else ''
                    if good_with_children == 'Yes':
                        feature_score += 0.10
                    elif good_with_children == 'No':
                        feature_score -= 0.20

                # Combine scores with balanced weights
                final_score = (
                    scaled_semantic * 0.35 +  # Reduced semantic weight
                    feature_score * 0.45 +    # Increased feature matching weight
                    breed_data['lifestyle_bonus'] * 0.15 +
                    breed_data['comparative_bonus'] * 0.05
                )

                # Calculate base compatibility score
                base_compatibility = final_score

                # Apply dynamic scoring with natural distribution
                if base_compatibility >= 0.9:  # Exceptional matches
                    score_range = (0.92, 0.98)
                    position = (base_compatibility - 0.9) / 0.1
                elif base_compatibility >= 0.75:  # Excellent matches
                    score_range = (0.85, 0.91)
                    position = (base_compatibility - 0.75) / 0.15
                elif base_compatibility >= 0.6:  # Good matches
                    score_range = (0.75, 0.84)
                    position = (base_compatibility - 0.6) / 0.15
                elif base_compatibility >= 0.45:  # Fair matches
                    score_range = (0.65, 0.74)
                    position = (base_compatibility - 0.45) / 0.15
                elif base_compatibility >= 0.3:  # Poor matches
                    score_range = (0.55, 0.64)
                    position = (base_compatibility - 0.3) / 0.15
                else:  # Very poor matches
                    score_range = (0.45, 0.54)
                    position = max(0, base_compatibility / 0.3)

                # Calculate final score with natural variation
                score_span = score_range[1] - score_range[0]
                base_score = score_range[0] + (position * score_span)

                # Add controlled random variation for natural ranking
                random.seed(hash(breed + user_input[:15]))
                variation = random.uniform(-0.015, 0.015)
                display_score = round(max(0.45, min(0.98, base_score + variation)), 3)

                breed_display_scores.append({
                    'breed': breed,
                    'display_score': display_score,
                    'semantic_score': base_semantic,
                    'comparative_bonus': breed_data['comparative_bonus'],
                    'lifestyle_bonus': breed_data['lifestyle_bonus']
                })

            # Sort by display score to ensure ranking consistency
            breed_display_scores.sort(key=lambda x: x['display_score'], reverse=True)
            top_breeds = breed_display_scores[:top_k]

            # Convert to standard recommendation format
            recommendations = []
            for i, breed_data in enumerate(top_breeds):
                breed = breed_data['breed']
                display_score = breed_data['display_score']

                # Get detailed information
                breed_info = get_dog_description(breed)

                recommendation = {
                    'breed': breed.replace('_', ' '),
                    'rank': i + 1,
                    'overall_score': display_score,  # Use display score for consistency
                    'final_score': display_score,    # Ensure final_score matches overall_score
                    'semantic_score': breed_data['semantic_score'],
                    'comparative_bonus': breed_data['comparative_bonus'],
                    'lifestyle_bonus': breed_data['lifestyle_bonus'],
                    'size': breed_info.get('Size', 'Unknown') if breed_info else 'Unknown',
                    'temperament': breed_info.get('Temperament', '') if breed_info else '',
                    'exercise_needs': breed_info.get('Exercise Needs', 'Moderate') if breed_info else 'Moderate',
                    'grooming_needs': breed_info.get('Grooming Needs', 'Moderate') if breed_info else 'Moderate',
                    'good_with_children': breed_info.get('Good with Children', 'Yes') if breed_info else 'Yes',
                    'lifespan': breed_info.get('Lifespan', '10-12 years') if breed_info else '10-12 years',
                    'description': breed_info.get('Description', '') if breed_info else '',
                    'search_type': 'description'
                }

                recommendations.append(recommendation)

            print(f"Generated {len(recommendations)} semantic recommendations")
            return recommendations

        except Exception as e:
            print(f"Failed to generate semantic recommendations: {str(e)}")
            print(traceback.format_exc())
            return []

    def _calculate_lifestyle_bonus(self, breed_characteristics: Dict[str, Any],
                                 lifestyle_keywords: Dict[str, List[str]]) -> float:
        """Enhanced lifestyle matching bonus calculation"""
        bonus = 0.0
        penalties = 0.0

        # Enhanced size matching
        breed_size = breed_characteristics.get('size', '').lower()
        size_prefs = lifestyle_keywords.get('size_preference', [])
        for pref in size_prefs:
            if pref in breed_size:
                bonus += 0.25  # Strong reward for size match
            elif (pref == 'small' and 'large' in breed_size) or \
                 (pref == 'large' and 'small' in breed_size):
                penalties += 0.15  # Penalty for size mismatch

        # Enhanced activity level matching
        breed_exercise = breed_characteristics.get('exercise_needs', '').lower()
        activity_prefs = lifestyle_keywords.get('activity_level', [])

        if 'high' in activity_prefs:
            if 'high' in breed_exercise or 'very high' in breed_exercise:
                bonus += 0.2
            elif 'low' in breed_exercise:
                penalties += 0.2
        elif 'low' in activity_prefs:
            if 'low' in breed_exercise:
                bonus += 0.2
            elif 'high' in breed_exercise or 'very high' in breed_exercise:
                penalties += 0.25
        elif 'moderate' in activity_prefs:
            if 'moderate' in breed_exercise:
                bonus += 0.15

        # Enhanced family situation matching
        good_with_children = breed_characteristics.get('good_with_children', 'Yes')
        family_prefs = lifestyle_keywords.get('family_situation', [])

        if 'children' in family_prefs:
            if good_with_children == 'Yes':
                bonus += 0.15
            else:
                penalties += 0.3  # Strong penalty for non-child-friendly breeds

        # Enhanced living space matching
        living_prefs = lifestyle_keywords.get('living_space', [])
        if 'apartment' in living_prefs:
            if 'small' in breed_size:
                bonus += 0.2
            elif 'medium' in breed_size and 'low' in breed_exercise:
                bonus += 0.1
            elif 'large' in breed_size or 'giant' in breed_size:
                penalties += 0.2  # Penalty for large dogs in apartments

        # Noise preference matching
        noise_prefs = lifestyle_keywords.get('noise_preference', [])
        temperament = breed_characteristics.get('temperament', '').lower()

        if 'low' in noise_prefs:
            # Reward quiet breeds
            if any(term in temperament for term in ['gentle', 'calm', 'quiet']):
                bonus += 0.1

        # Care level matching
        grooming_needs = breed_characteristics.get('grooming_needs', '').lower()
        care_prefs = lifestyle_keywords.get('care_level', [])

        if 'low' in care_prefs and 'low' in grooming_needs:
            bonus += 0.1
        elif 'high' in care_prefs and 'high' in grooming_needs:
            bonus += 0.1
        elif 'low' in care_prefs and 'high' in grooming_needs:
            penalties += 0.15

        # Special needs matching
        special_needs = lifestyle_keywords.get('special_needs', [])

        if 'guard' in special_needs:
            if any(term in temperament for term in ['protective', 'alert', 'watchful']):
                bonus += 0.1
        elif 'companion' in special_needs:
            if any(term in temperament for term in ['affectionate', 'gentle', 'loyal']):
                bonus += 0.1

        # Calculate final bonus with penalties
        final_bonus = bonus - penalties
        return max(-0.3, min(0.5, final_bonus))  # Allow negative bonus but limit range

    def _get_breed_info_from_standardized(self, standardized_info) -> Dict[str, Any]:
        """Convert standardized breed info to dictionary format"""
        try:
            size_map = {1: 'Tiny', 2: 'Small', 3: 'Medium', 4: 'Large', 5: 'Giant'}
            exercise_map = {1: 'Low', 2: 'Moderate', 3: 'High', 4: 'Very High'}
            care_map = {1: 'Low', 2: 'Moderate', 3: 'High'}

            return {
                'Size': size_map.get(standardized_info.size_category, 'Medium'),
                'Exercise Needs': exercise_map.get(standardized_info.exercise_level, 'Moderate'),
                'Grooming Needs': care_map.get(standardized_info.care_complexity, 'Moderate'),
                'Good with Children': 'Yes' if standardized_info.child_compatibility >= 0.8 else
                                     'No' if standardized_info.child_compatibility <= 0.2 else 'Unknown',
                'Temperament': 'Varies by individual',
                'Lifespan': '10-12 years',
                'Description': f'A {size_map.get(standardized_info.size_category, "medium")} sized breed'
            }
        except Exception as e:
            print(f"Error converting standardized info: {str(e)}")
            return {}

    def _get_fallback_recommendations(self, top_k: int = 15) -> List[Dict[str, Any]]:
        """Get fallback recommendations when enhanced system fails"""
        try:
            safe_breeds = [
                ('Labrador Retriever', 0.85),
                ('Golden Retriever', 0.82),
                ('Cavalier King Charles Spaniel', 0.80),
                ('French Bulldog', 0.78),
                ('Boston Terrier', 0.76),
                ('Bichon Frise', 0.74),
                ('Pug', 0.72),
                ('Cocker Spaniel', 0.70)
            ]

            recommendations = []
            for i, (breed, score) in enumerate(safe_breeds[:top_k]):
                breed_info = get_dog_description(breed.replace(' ', '_')) or {}

                recommendation = {
                    'breed': breed,
                    'rank': i + 1,
                    'overall_score': score,
                    'final_score': score,
                    'semantic_score': score * 0.8,
                    'comparative_bonus': 0.0,
                    'lifestyle_bonus': 0.0,
                    'size': breed_info.get('Size', 'Unknown'),
                    'temperament': breed_info.get('Temperament', ''),
                    'exercise_needs': breed_info.get('Exercise Needs', 'Moderate'),
                    'grooming_needs': breed_info.get('Grooming Needs', 'Moderate'),
                    'good_with_children': breed_info.get('Good with Children', 'Yes'),
                    'lifespan': breed_info.get('Lifespan', '10-12 years'),
                    'description': breed_info.get('Description', ''),
                    'search_type': 'fallback'
                }
                recommendations.append(recommendation)

            return recommendations

        except Exception as e:
            print(f"Error generating fallback recommendations: {str(e)}")
            return []

    def get_enhanced_recommendations_with_unified_scoring(self, user_input: str, top_k: int = 15) -> List[Dict[str, Any]]:
        """簡化的增強推薦方法"""
        try:
            print(f"Processing enhanced recommendation: {user_input[:50]}...")

            # 使用基本語意匹配
            return self.get_semantic_recommendations(user_input, top_k)

        except Exception as e:
            error_msg = f"Enhanced recommendation error: {str(e)}. Please check your description."
            print(f"ERROR: {error_msg}")
            print(traceback.format_exc())
            raise RuntimeError(error_msg) from e

    def _analyze_user_description_enhanced(self, user_description: str) -> Dict[str, Any]:
        """增強用戶描述分析"""
        text = user_description.lower()
        analysis = {
            'mentioned_breeds': [],
            'lifestyle_keywords': {},
            'preference_strength': {},
            'constraint_requirements': [],
            'user_context': {}
        }

        # 提取提及的品種
        for breed in self.breed_list:
            breed_display = breed.replace('_', ' ').lower()
            if breed_display in text or any(word in text for word in breed_display.split()):
                analysis['mentioned_breeds'].append(breed)
                # 簡單偏好強度分析
                if any(word in text for word in ['love', 'prefer', 'like', '喜歡', '最愛']):
                    analysis['preference_strength'][breed] = 0.8
                else:
                    analysis['preference_strength'][breed] = 0.5

        # 提取約束要求
        if any(word in text for word in ['quiet', 'silent', 'no barking', '安靜']):
            analysis['constraint_requirements'].append('low_noise')
        if any(word in text for word in ['apartment', 'small space', '公寓']):
            analysis['constraint_requirements'].append('apartment_suitable')
        if any(word in text for word in ['children', 'kids', 'family', '小孩']):
            analysis['constraint_requirements'].append('child_friendly')

        # 提取用戶背景
        analysis['user_context'] = {
            'has_children': any(word in text for word in ['children', 'kids', '小孩']),
            'living_space': 'apartment' if any(word in text for word in ['apartment', '公寓']) else 'house',
            'activity_level': 'high' if any(word in text for word in ['active', 'energetic', '活躍']) else 'moderate',
            'noise_sensitive': any(word in text for word in ['quiet', 'silent', '安靜']),
            'experience_level': 'beginner' if any(word in text for word in ['first time', 'beginner', '新手']) else 'intermediate'
        }

        return analysis

    def _create_user_preferences_from_analysis_enhanced(self, analysis: Dict[str, Any]) -> UserPreferences:
        """從分析結果創建用戶偏好物件"""
        context = analysis['user_context']

        # 推斷居住空間類型
        living_space = 'apartment' if context.get('living_space') == 'apartment' else 'house_small'

        # 推斷院子權限
        yard_access = 'no_yard' if living_space == 'apartment' else 'shared_yard'

        # 推斷運動時間
        activity_level = context.get('activity_level', 'moderate')
        exercise_time_map = {'high': 120, 'moderate': 60, 'low': 30}
        exercise_time = exercise_time_map.get(activity_level, 60)

        # 推斷運動類型
        exercise_type_map = {'high': 'active_training', 'moderate': 'moderate_activity', 'low': 'light_walks'}
        exercise_type = exercise_type_map.get(activity_level, 'moderate_activity')

        # 推斷噪音容忍度
        noise_tolerance = 'low' if context.get('noise_sensitive', False) else 'medium'

        return UserPreferences(
            living_space=living_space,
            yard_access=yard_access,
            exercise_time=exercise_time,
            exercise_type=exercise_type,
            grooming_commitment='medium',
            experience_level=context.get('experience_level', 'intermediate'),
            time_availability='moderate',
            has_children=context.get('has_children', False),
            children_age='school_age' if context.get('has_children', False) else None,
            noise_tolerance=noise_tolerance,
            space_for_play=(living_space != 'apartment'),
            other_pets=False,
            climate='moderate',
            health_sensitivity='medium',
            barking_acceptance=noise_tolerance,
            size_preference='no_preference'
        )

    def _get_candidate_breeds_enhanced(self, analysis: Dict[str, Any]) -> List[str]:
        """獲取候選品種列表"""
        candidate_breeds = set()

        # 如果提及特定品種，優先包含
        if analysis['mentioned_breeds']:
            candidate_breeds.update(analysis['mentioned_breeds'])

        # 根據約束要求過濾品種
        if 'apartment_suitable' in analysis['constraint_requirements']:
            apartment_suitable = [
                'French_Bulldog', 'Cavalier_King_Charles_Spaniel', 'Boston_Terrier',
                'Pug', 'Bichon_Frise', 'Cocker_Spaniel', 'Yorkshire_Terrier', 'Shih_Tzu'
            ]
            candidate_breeds.update(breed for breed in apartment_suitable if breed in self.breed_list)

        if 'child_friendly' in analysis['constraint_requirements']:
            child_friendly = [
                'Labrador_Retriever', 'Golden_Retriever', 'Beagle', 'Cavalier_King_Charles_Spaniel',
                'Bichon_Frise', 'Poodle', 'Cocker_Spaniel'
            ]
            candidate_breeds.update(breed for breed in child_friendly if breed in self.breed_list)

        # 如果候選品種不足，添加更多通用品種
        if len(candidate_breeds) < 20:
            general_breeds = [
                'Labrador_Retriever', 'German_Shepherd', 'Golden_Retriever', 'French_Bulldog',
                'Bulldog', 'Poodle', 'Beagle', 'Rottweiler', 'Yorkshire_Terrier', 'Boston_Terrier',
                'Border_Collie', 'Siberian_Husky', 'Cavalier_King_Charles_Spaniel', 'Boxer',
                'Bichon_Frise', 'Cocker_Spaniel', 'Shih_Tzu', 'Pug', 'Chihuahua'
            ]
            candidate_breeds.update(breed for breed in general_breeds if breed in self.breed_list)

        return list(candidate_breeds)[:30]  # 限制候選數量以提高效率

    def _apply_constraint_filtering_enhanced(self, breed: str, analysis: Dict[str, Any]) -> float:
        """應用約束過濾，返回調整分數"""
        penalty = 0.0

        breed_info = get_dog_description(breed)
        if not breed_info:
            return penalty

        # 低噪音要求
        if 'low_noise' in analysis['constraint_requirements']:
            noise_info = breed_noise_info.get(breed, {})
            noise_level = noise_info.get('noise_level', 'moderate').lower()
            if 'high' in noise_level:
                penalty -= 0.3  # 嚴重扣分
            elif 'low' in noise_level:
                penalty += 0.1  # 輕微加分

        # 公寓適合性
        if 'apartment_suitable' in analysis['constraint_requirements']:
            size = breed_info.get('Size', '').lower()
            exercise_needs = breed_info.get('Exercise Needs', '').lower()

            if size in ['large', 'giant']:
                penalty -= 0.2
            elif size in ['small', 'tiny']:
                penalty += 0.1

            if 'high' in exercise_needs:
                penalty -= 0.15

        # 兒童友善性
        if 'child_friendly' in analysis['constraint_requirements']:
            good_with_children = breed_info.get('Good with Children', 'Unknown')
            if good_with_children == 'Yes':
                penalty += 0.15
            elif good_with_children == 'No':
                penalty -= 0.4  # 嚴重扣分

        return penalty

    def _get_breed_characteristics_enhanced(self, breed: str) -> Dict[str, Any]:
        """獲取品種特徵"""
        breed_info = get_dog_description(breed)
        if not breed_info:
            return {}

        characteristics = {
            'size': breed_info.get('Size', 'Unknown'),
            'temperament': breed_info.get('Temperament', ''),
            'exercise_needs': breed_info.get('Exercise Needs', 'Moderate'),
            'grooming_needs': breed_info.get('Grooming Needs', 'Moderate'),
            'good_with_children': breed_info.get('Good with Children', 'Unknown'),
            'lifespan': breed_info.get('Lifespan', '10-12 years'),
            'description': breed_info.get('Description', '')
        }

        # 添加噪音資訊
        noise_info = breed_noise_info.get(breed, {})
        characteristics['noise_level'] = noise_info.get('noise_level', 'moderate')

        return characteristics

    def get_hybrid_recommendations(self, user_description: str,
                                 user_preferences: Optional[Any] = None,
                                 top_k: int = 15) -> List[Dict[str, Any]]:
        """
        Hybrid recommendations: Combine semantic matching with traditional scoring

        Args:
            user_description: User's natural language description
            user_preferences: Optional structured preference settings
            top_k: Number of recommendations to return

        Returns:
            Hybrid recommendation results
        """
        try:
            # Get semantic recommendations
            semantic_recommendations = self.get_semantic_recommendations(user_description, top_k * 2)

            if not user_preferences:
                return semantic_recommendations[:top_k]

            # Combine with traditional scoring
            hybrid_results = []

            for semantic_rec in semantic_recommendations:
                breed_name = semantic_rec['breed'].replace(' ', '_')

                # Calculate traditional compatibility score
                traditional_score = calculate_compatibility_score(user_preferences, breed_name)

                # Hybrid score (semantic 40% + traditional 60%)
                hybrid_score = (
                    semantic_rec['overall_score'] * 0.4 +
                    traditional_score * 0.6
                )

                semantic_rec['hybrid_score'] = hybrid_score
                semantic_rec['traditional_score'] = traditional_score
                hybrid_results.append(semantic_rec)

            # Re-sort by hybrid score
            hybrid_results.sort(key=lambda x: x['hybrid_score'], reverse=True)

            # Update rankings
            for i, result in enumerate(hybrid_results[:top_k]):
                result['rank'] = i + 1
                result['overall_score'] = result['hybrid_score']

            return hybrid_results[:top_k]

        except Exception as e:
            print(f"Hybrid recommendation failed: {str(e)}")
            print(traceback.format_exc())
            return self.get_semantic_recommendations(user_description, top_k)

def get_breed_recommendations_by_description(user_description: str,
                                           user_preferences: Optional[Any] = None,
                                           top_k: int = 15) -> List[Dict[str, Any]]:
    """Main interface function for getting breed recommendations by description"""
    try:
        print("Initializing Enhanced SemanticBreedRecommender...")
        recommender = SemanticBreedRecommender()
        
        # 嘗試載入SBERT模型（如果尚未載入）
        if not recommender.sbert_model:
            recommender._initialize_model()

        # 優先使用整合統一評分系統的增強推薦
        print("Using enhanced recommendation system with unified scoring")
        results = recommender.get_enhanced_recommendations_with_unified_scoring(user_description, top_k)

        if results and len(results) > 0:
            print(f"Generated {len(results)} enhanced recommendations successfully")
            return results
        else:
            # 如果增強系統無結果，嘗試原有增強系統
            print("Enhanced unified system returned no results, trying original enhanced system")
            results = recommender.get_enhanced_semantic_recommendations(user_description, top_k)

            if results and len(results) > 0:
                return results
            else:
                # 最後回退到標準系統
                print("All enhanced systems failed, using standard system")
                if user_preferences:
                    results = recommender.get_hybrid_recommendations(user_description, user_preferences, top_k)
                else:
                    results = recommender.get_semantic_recommendations(user_description, top_k)

                if not results:
                    error_msg = f"All recommendation systems failed to generate results. Please check your input description and try again. Error details may be in the console."
                    print(f"ERROR: {error_msg}")
                    raise RuntimeError(error_msg)
                return results

    except Exception as e:
        error_msg = f"Critical error in recommendation system: {str(e)}. Please check your input and system configuration."
        print(f"ERROR: {error_msg}")
        print(traceback.format_exc())
        raise RuntimeError(error_msg) from e


def get_enhanced_recommendations_with_unified_scoring(user_description: str, top_k: int = 15) -> List[Dict[str, Any]]:
    """簡化版本：基本語意推薦功能"""
    try:
        print(f"Processing description-based recommendation: {user_description[:50]}...")

        # 創建基本推薦器實例
        recommender = SemanticBreedRecommender()

        # 嘗試載入SBERT模型（如果尚未載入）
        if not recommender.sbert_model:
            recommender._initialize_model()
            
        if not recommender.sbert_model:
            print("SBERT model not available, using basic text matching...")
            # 使用基本文字匹配邏輯
            return _get_basic_text_matching_recommendations(user_description, top_k)

        # 確保breed vectors已建構
        if not recommender.breed_vectors:
            recommender._build_breed_vectors()

        # 使用語意相似度推薦
        recommendations = []
        user_embedding = recommender.sbert_model.encode(user_description)

        # 計算所有品種的增強分數
        all_breed_scores = []
        for breed_name, breed_vector in recommender.breed_vectors.items():
            breed_embedding = breed_vector.embedding
            similarity = cosine_similarity([user_embedding], [breed_embedding])[0][0]

            # 獲取品種資料
            breed_info = get_dog_description(breed_name) or {}

            # 計算增強的匹配分數
            enhanced_score = _calculate_enhanced_matching_score(
                breed_name, breed_info, user_description, similarity
            )

            all_breed_scores.append((breed_name, enhanced_score, breed_info, similarity))

        # 按 final_score 排序（而不是語意相似度）
        all_breed_scores.sort(key=lambda x: x[1]['final_score'], reverse=True)
        top_breeds = all_breed_scores[:top_k]

        for i, (breed, enhanced_score, breed_info, similarity) in enumerate(top_breeds):
            recommendation = {
                'breed': breed.replace('_', ' '),
                'rank': i + 1,  # 正確的排名
                'overall_score': enhanced_score['final_score'],
                'final_score': enhanced_score['final_score'],
                'semantic_score': similarity,
                'comparative_bonus': enhanced_score['lifestyle_bonus'],
                'lifestyle_bonus': enhanced_score['lifestyle_bonus'],
                'size': breed_info.get('Size', 'Unknown'),
                'temperament': breed_info.get('Temperament', 'Unknown'),
                'exercise_needs': breed_info.get('Exercise Needs', 'Moderate'),
                'grooming_needs': breed_info.get('Grooming Needs', 'Moderate'),
                'good_with_children': breed_info.get('Good with Children', 'Unknown'),
                'lifespan': breed_info.get('Lifespan', '10-12 years'),
                'description': breed_info.get('Description', 'No description available'),
                'search_type': 'description',
                'scores': enhanced_score['dimension_scores']
            }
            recommendations.append(recommendation)

        print(f"Generated {len(recommendations)} semantic recommendations")
        return recommendations

    except Exception as e:
        error_msg = f"Error in semantic recommendation system: {str(e)}. Please check your input and try again."
        print(f"ERROR: {error_msg}")
        print(traceback.format_exc())
        raise RuntimeError(error_msg) from e

def _calculate_enhanced_matching_score(breed: str, breed_info: dict, user_description: str, base_similarity: float) -> dict:
    """計算增強的匹配分數，基於用戶描述和品種特性"""
    try:
        user_desc = user_description.lower()

        # 分析用戶需求
        space_requirements = _analyze_space_requirements(user_desc)
        exercise_requirements = _analyze_exercise_requirements(user_desc)
        noise_requirements = _analyze_noise_requirements(user_desc)
        size_requirements = _analyze_size_requirements(user_desc)
        family_requirements = _analyze_family_requirements(user_desc)

        # 獲取品種特性
        breed_size = breed_info.get('Size', '').lower()
        breed_exercise = breed_info.get('Exercise Needs', '').lower()
        breed_noise = breed_noise_info.get(breed, {}).get('noise_level', 'moderate').lower()
        breed_temperament = breed_info.get('Temperament', '').lower()
        breed_good_with_children = breed_info.get('Good with Children', '').lower()

        # 計算各維度匹配分數
        dimension_scores = {}

        # 空間匹配 (30% 權重)
        space_score = _calculate_space_compatibility(space_requirements, breed_size, breed_exercise)
        dimension_scores['space'] = space_score

        # 運動需求匹配 (25% 權重)
        exercise_score = _calculate_exercise_compatibility(exercise_requirements, breed_exercise)
        dimension_scores['exercise'] = exercise_score

        # 噪音匹配 (20% 權重)
        noise_score = _calculate_noise_compatibility(noise_requirements, breed_noise)
        dimension_scores['noise'] = noise_score

        # 體型匹配 (15% 權重)
        size_score = _calculate_size_compatibility(size_requirements, breed_size)
        dimension_scores['grooming'] = min(0.9, base_similarity + 0.1)  # 美容需求基於語意相似度

        # 家庭相容性 (10% 權重)
        family_score = _calculate_family_compatibility(family_requirements, breed_good_with_children, breed_temperament)
        dimension_scores['family'] = family_score
        dimension_scores['experience'] = min(0.9, base_similarity + 0.05)  # 經驗需求基於語意相似度

        # 應用硬約束過濾
        constraint_penalty = _apply_hard_constraints_enhanced(user_desc, breed_info)

        # 計算加權總分 - 精確化維度權重配置
        # 根據指導建議重新平衡維度權重
        weighted_score = (
            space_score * 0.30 +      # 空間相容性（降低5%）
            exercise_score * 0.28 +   # 運動需求匹配（降低2%）
            noise_score * 0.18 +      # 噪音控制（提升3%）
            family_score * 0.12 +     # 家庭相容性（提升2%）
            size_score * 0.08 +       # 體型匹配（降低2%）
            min(0.9, base_similarity + 0.1) * 0.04  # 護理需求（新增獨立權重）
        )

        # 優化完美匹配獎勵機制 - 降低觸發門檻並增加層次
        perfect_match_bonus = 0.0
        if space_score >= 0.88 and exercise_score >= 0.88 and noise_score >= 0.85:
            perfect_match_bonus = 0.08  # 卓越匹配獎勵
        elif space_score >= 0.82 and exercise_score >= 0.82 and noise_score >= 0.75:
            perfect_match_bonus = 0.04  # 優秀匹配獎勵
        elif space_score >= 0.75 and exercise_score >= 0.75:
            perfect_match_bonus = 0.02  # 良好匹配獎勵

        # 結合語意相似度與維度匹配 - 調整為75%維度匹配 25%語義相似度
        base_combined_score = (weighted_score * 0.75 + base_similarity * 0.25) + perfect_match_bonus

        # 應用漸進式約束懲罰，但確保基礎分數保障
        raw_final_score = base_combined_score + constraint_penalty

        # 實施動態分數保障機制 - 提升至40-42%基礎分數
        # 根據品種特性動態調整基礎分數
        base_guaranteed_score = 0.42  # 提升基礎保障分數

        # 特殊品種基礎分數調整
        high_adaptability_breeds = ['French_Bulldog', 'Pug', 'Golden_Retriever', 'Labrador_Retriever']
        if any(breed in breed for breed in high_adaptability_breeds):
            base_guaranteed_score = 0.45  # 高適應性品種更高基礎分數

        # 動態分數分佈優化
        if raw_final_score >= base_guaranteed_score:
            # 對於高分品種，實施適度壓縮避免過度集中
            if raw_final_score > 0.85:
                compression_factor = 0.92  # 輕度壓縮高分
                final_score = 0.85 + (raw_final_score - 0.85) * compression_factor
            else:
                final_score = raw_final_score
            final_score = min(0.93, final_score)  # 降低最高分數限制
        else:
            # 對於低分品種，使用改進的保障機制
            normalized_raw_score = max(0.15, raw_final_score)
            # 基礎保障75% + 實際計算25%，保持一定區分度
            final_score = base_guaranteed_score * 0.75 + normalized_raw_score * 0.25
            final_score = max(base_guaranteed_score, min(0.93, final_score))

        lifestyle_bonus = max(0.0, weighted_score - base_similarity)

        return {
            'final_score': final_score,
            'weighted_score': weighted_score,
            'lifestyle_bonus': lifestyle_bonus,
            'dimension_scores': dimension_scores,
            'constraint_penalty': constraint_penalty
        }

    except Exception as e:
        print(f"Error in enhanced matching calculation for {breed}: {str(e)}")
        return {
            'final_score': base_similarity,
            'weighted_score': base_similarity,
            'lifestyle_bonus': 0.0,
            'dimension_scores': {
                'space': base_similarity * 0.9,
                'exercise': base_similarity * 0.85,
                'grooming': base_similarity * 0.8,
                'experience': base_similarity * 0.75,
                'noise': base_similarity * 0.7,
                'family': base_similarity * 0.65
            },
            'constraint_penalty': 0.0
        }

def _analyze_space_requirements(user_desc: str) -> dict:
    """分析空間需求 - 增強中等活動量識別"""
    requirements = {'type': 'unknown', 'size': 'medium', 'importance': 0.5}

    if any(word in user_desc for word in ['apartment', 'small apartment', 'small space', 'condo', 'flat']):
        requirements['type'] = 'apartment'
        requirements['size'] = 'small'
        requirements['importance'] = 0.95  # 提高重要性
    elif any(word in user_desc for word in ['medium-sized house', 'medium house', 'townhouse']):
        requirements['type'] = 'medium_house'
        requirements['size'] = 'medium'
        requirements['importance'] = 0.8  # 中等活動量用戶的特殊標記
    elif any(word in user_desc for word in ['large house', 'big house', 'yard', 'garden', 'large space', 'backyard']):
        requirements['type'] = 'house'
        requirements['size'] = 'large'
        requirements['importance'] = 0.7

    return requirements

def _analyze_exercise_requirements(user_desc: str) -> dict:
    """分析運動需求 - 增強中等活動量識別"""
    requirements = {'level': 'moderate', 'importance': 0.5}

    # 低運動量識別
    if any(word in user_desc for word in ["don't exercise", "don't exercise much", "low exercise", "minimal", "lazy", "not active"]):
        requirements['level'] = 'low'
        requirements['importance'] = 0.95
    # 中等運動量的精確識別
    elif any(phrase in user_desc for phrase in ['30 minutes', 'half hour', 'moderate', 'balanced', 'walk about']):
        if 'walk' in user_desc or 'daily' in user_desc:
            requirements['level'] = 'moderate'
            requirements['importance'] = 0.85  # 中等活動量的特殊標記
    # 高運動量識別
    elif any(word in user_desc for word in ['active', 'hiking', 'outdoor activities', 'running', 'outdoors', 'love hiking']):
        requirements['level'] = 'high'
        requirements['importance'] = 0.9

    return requirements

def _analyze_noise_requirements(user_desc: str) -> dict:
    """分析噪音需求"""
    requirements = {'tolerance': 'medium', 'importance': 0.5}

    if any(word in user_desc for word in ['quiet', 'no bark', "won't bark", "doesn't bark", 'silent', 'peaceful']):
        requirements['tolerance'] = 'low'
        requirements['importance'] = 0.9
    elif any(word in user_desc for word in ['loud', 'barking ok', 'noise ok']):
        requirements['tolerance'] = 'high'
        requirements['importance'] = 0.7

    return requirements

def _analyze_size_requirements(user_desc: str) -> dict:
    """分析體型需求"""
    requirements = {'preferred': 'any', 'importance': 0.5}

    if any(word in user_desc for word in ['small', 'tiny', 'little', 'lap dog', 'compact']):
        requirements['preferred'] = 'small'
        requirements['importance'] = 0.8
    elif any(word in user_desc for word in ['large', 'big', 'giant']):
        requirements['preferred'] = 'large'
        requirements['importance'] = 0.8

    return requirements

def _analyze_family_requirements(user_desc: str) -> dict:
    """分析家庭需求"""
    requirements = {'children': False, 'importance': 0.3}

    if any(word in user_desc for word in ['children', 'kids', 'family', 'child']):
        requirements['children'] = True
        requirements['importance'] = 0.8

    return requirements

def _calculate_space_compatibility(space_req: dict, breed_size: str, breed_exercise: str) -> float:
    """計算空間相容性分數 - 增強中等活動量處理"""
    if space_req['type'] == 'apartment':
        if 'small' in breed_size or 'toy' in breed_size:
            base_score = 0.95
        elif 'medium' in breed_size:
            if 'low' in breed_exercise:
                base_score = 0.75
            else:
                base_score = 0.45  # 降低中型犬在公寓的分數
        elif 'large' in breed_size:
            base_score = 0.05  # 大型犬極度不適合公寓
        elif 'giant' in breed_size:
            base_score = 0.01  # 超大型犬完全不適合公寓
        else:
            base_score = 0.7
    elif space_req['type'] == 'medium_house':
        # 中型房屋的特殊處理 - 適合中等活動量用戶
        if 'small' in breed_size or 'toy' in breed_size:
            base_score = 0.9
        elif 'medium' in breed_size:
            base_score = 0.95  # 中型犬在中型房屋很適合
        elif 'large' in breed_size:
            if 'moderate' in breed_exercise or 'low' in breed_exercise:
                base_score = 0.8  # 低運動量大型犬還可以
            else:
                base_score = 0.6  # 高運動量大型犬不太適合
        elif 'giant' in breed_size:
            base_score = 0.3  # 超大型犬在中型房屋不太適合
        else:
            base_score = 0.85
    else:
        # 大型房屋的情況
        if 'small' in breed_size or 'toy' in breed_size:
            base_score = 0.85
        elif 'medium' in breed_size:
            base_score = 0.9
        elif 'large' in breed_size or 'giant' in breed_size:
            base_score = 0.95
        else:
            base_score = 0.8

    return min(0.95, base_score)

def _calculate_exercise_compatibility(exercise_req: dict, breed_exercise: str) -> float:
    """計算運動需求相容性分數 - 增強中等活動量處理"""
    if exercise_req['level'] == 'low':
        if 'low' in breed_exercise or 'minimal' in breed_exercise:
            return 0.95
        elif 'moderate' in breed_exercise:
            return 0.5  # 降低不匹配分數
        elif 'high' in breed_exercise:
            return 0.1  # 進一步降低高運動需求的匹配
        else:
            return 0.7
    elif exercise_req['level'] == 'high':
        if 'high' in breed_exercise:
            return 0.95
        elif 'moderate' in breed_exercise:
            return 0.8
        elif 'low' in breed_exercise:
            return 0.6
        else:
            return 0.7
    else:  # moderate - 中等活動量的精確處理
        if 'moderate' in breed_exercise:
            return 0.95  # 完美匹配
        elif 'low' in breed_exercise:
            return 0.85  # 低運動需求的品種對中等活動量用戶也不錯
        elif 'high' in breed_exercise:
            return 0.5  # 中等活動量用戶不太適合高運動需求品種
        else:
            return 0.75

    return 0.6

def _calculate_noise_compatibility(noise_req: dict, breed_noise: str) -> float:
    """計算噪音相容性分數，更好處理複合等級"""
    breed_noise_lower = breed_noise.lower()

    if noise_req['tolerance'] == 'low':
        if 'low' in breed_noise_lower and 'moderate' not in breed_noise_lower:
            return 0.95  # 純低噪音
        elif 'low-moderate' in breed_noise_lower or 'low to moderate' in breed_noise_lower:
            return 0.8   # 低到中等噪音，還可接受
        elif breed_noise_lower in ['moderate']:
            return 0.4   # 中等噪音有些問題
        elif 'high' in breed_noise_lower:
            return 0.1   # 高噪音不適合
        else:
            return 0.6   # 未知噪音水平，保守估計
    elif noise_req['tolerance'] == 'high':
        if 'high' in breed_noise_lower:
            return 0.9
        elif 'moderate' in breed_noise_lower:
            return 0.85
        elif 'low' in breed_noise_lower:
            return 0.8   # 安靜犬對高容忍度的人也很好
        else:
            return 0.8
    else:  # moderate tolerance
        if 'moderate' in breed_noise_lower:
            return 0.9
        elif 'low' in breed_noise_lower:
            return 0.85
        elif 'high' in breed_noise_lower:
            return 0.6
        else:
            return 0.75

    return 0.7

def _calculate_size_compatibility(size_req: dict, breed_size: str) -> float:
    """計算體型相容性分數"""
    if size_req['preferred'] == 'small':
        if any(word in breed_size for word in ['small', 'toy', 'tiny']):
            return 0.9
        elif 'medium' in breed_size:
            return 0.6
        else:
            return 0.3
    elif size_req['preferred'] == 'large':
        if any(word in breed_size for word in ['large', 'giant']):
            return 0.9
        elif 'medium' in breed_size:
            return 0.7
        else:
            return 0.4

    return 0.7  # 無特別偏好

def _calculate_family_compatibility(family_req: dict, good_with_children: str, temperament: str) -> float:
    """計算家庭相容性分數"""
    if family_req['children']:
        if 'yes' in good_with_children.lower():
            return 0.9
        elif any(word in temperament for word in ['gentle', 'patient', 'friendly']):
            return 0.8
        elif 'no' in good_with_children.lower():
            return 0.2
        else:
            return 0.6

    return 0.7

def _apply_hard_constraints_enhanced(user_desc: str, breed_info: dict) -> float:
    """應用品種特性感知的動態懲罰機制"""
    penalty = 0.0

    # 建立懲罰衰減係數和補償機制
    penalty_decay_factor = 0.7
    breed_adaptability_bonus = 0.0
    breed_size = breed_info.get('Size', '').lower()
    breed_exercise = breed_info.get('Exercise Needs', '').lower()
    breed_name = breed_info.get('Breed', '').replace(' ', '_')

    # 公寓空間約束 - 品種特性感知懲罰機制
    if 'apartment' in user_desc or 'small apartment' in user_desc:
        if 'giant' in breed_size:
            base_penalty = -0.35  # 減少基礎懲罰
            # 特定品種適應性補償
            adaptable_giants = ['Mastiff', 'Great Dane']  # 相對安靜的巨型犬
            if any(adapt_breed in breed_name for adapt_breed in adaptable_giants):
                breed_adaptability_bonus += 0.08
            penalty += base_penalty * penalty_decay_factor
        elif 'large' in breed_size:
            base_penalty = -0.25  # 減少大型犬懲罰
            # 適合公寓的大型犬補償
            apartment_friendly_large = ['Greyhound', 'Great_Dane']
            if any(apt_breed in breed_name for apt_breed in apartment_friendly_large):
                breed_adaptability_bonus += 0.06
            penalty += base_penalty * penalty_decay_factor
        elif 'medium' in breed_size and 'high' in breed_exercise:
            penalty += -0.15 * penalty_decay_factor  # 進一步減少懲罰

    # 運動需求不匹配 - 品種特性感知懲罰機制
    if any(phrase in user_desc for phrase in ["don't exercise", "not active", "low exercise", "don't exercise much"]):
        if 'high' in breed_exercise:
            base_penalty = -0.28  # 減少基礎懲罰
            # 低維護高運動犬種補償
            adaptable_high_energy = ['Greyhound', 'Whippet']  # 運動爆發型，平時安靜
            if any(adapt_breed in breed_name for adapt_breed in adaptable_high_energy):
                breed_adaptability_bonus += 0.10
            penalty += base_penalty * penalty_decay_factor
        elif 'moderate' in breed_exercise:
            penalty += -0.08 * penalty_decay_factor  # 進一步減少懲罰

    # 噪音控制需求不匹配 - 品種特性感知懲罰機制
    if any(phrase in user_desc for phrase in ['quiet', "won't bark", "doesn't bark", "silent"]):
        breed_noise = breed_noise_info.get(breed_name, {}).get('noise_level', 'moderate').lower()
        if 'high' in breed_noise:
            base_penalty = -0.18  # 減少基礎懲罰
            # 訓練性良好的高噪音品種補償
            trainable_vocal_breeds = ['German_Shepherd', 'Golden_Retriever']
            if any(train_breed in breed_name for train_breed in trainable_vocal_breeds):
                breed_adaptability_bonus += 0.05
            penalty += base_penalty * penalty_decay_factor
        elif 'moderate' in breed_noise and 'low' not in breed_noise:
            penalty += -0.05 * penalty_decay_factor

    # 體型偏好不匹配 - 漸進式懲罰
    if any(phrase in user_desc for phrase in ['small', 'tiny', 'little']):
        if 'giant' in breed_size:
            penalty -= 0.35  # 超大型犬懲罰
        elif 'large' in breed_size:
            penalty -= 0.20  # 大型犬懲罰

    # 中等活動量用戶的特殊約束處理 - 漸進式懲罰
    moderate_activity_terms = ['30 minutes', 'half hour', 'moderate', 'balanced', 'medium-sized house']
    if any(term in user_desc for term in moderate_activity_terms):
        # 超大型犬對中等活動量用戶的適度懲罰
        giant_breeds = ['Saint Bernard', 'Tibetan Mastiff', 'Great Dane', 'Mastiff', 'Newfoundland']
        if any(giant in breed_name for giant in giant_breeds) or 'giant' in breed_size:
            penalty -= 0.35  # 適度懲罰，不完全排除

        # 中型房屋 + 超大型犬的額外考量
        if 'medium-sized house' in user_desc and any(giant in breed_name for giant in giant_breeds):
            if not any(high_activity in user_desc for high_activity in ['hiking', 'running', 'active', 'outdoor activities']):
                penalty -= 0.15  # 輕度額外懲罰

    # 30分鐘散步對極高運動需求品種的懲罰
    if any(term in user_desc for term in ['30 minutes', 'half hour']) and 'walk' in user_desc:
        high_energy_breeds = ['Siberian Husky', 'Border Collie', 'Jack Russell Terrier', 'Weimaraner']
        if any(he_breed in breed_name for he_breed in high_energy_breeds) and 'high' in breed_exercise:
            penalty -= 0.25  # 適度懲罰極高運動需求品種

    # 添加特殊品種適應性補償機制
    # 對於邊界適配品種，給予適度補償
    boundary_adaptable_breeds = {
        'Italian_Greyhound': 0.08,  # 安靜、低維護的小型犬
        'Boston_Bull': 0.06,        # 適應性強的小型犬
        'Havanese': 0.05,           # 友好適應的小型犬
        'Silky_terrier': 0.04,      # 安靜的玩具犬
        'Basset': 0.07              # 低能量但友好的中型犬
    }

    if breed_name in boundary_adaptable_breeds:
        breed_adaptability_bonus += boundary_adaptable_breeds[breed_name]

    # 應用品種適應性補償並設置懲罰上限
    final_penalty = penalty + breed_adaptability_bonus
    # 限制最大懲罰，避免單一約束主導評分
    final_penalty = max(-0.4, final_penalty)

    return final_penalty

def _get_basic_text_matching_recommendations(user_description: str, top_k: int = 15) -> List[Dict[str, Any]]:
    """基本文字匹配推薦（SBERT 不可用時的後備方案）"""
    try:
        print("Using basic text matching as fallback...")

        # 基本關鍵字匹配
        keywords = user_description.lower().split()
        breed_scores = []

        # 從數據庫獲取品種清單
        try:
            conn = sqlite3.connect('animal_detector.db')
            cursor = conn.cursor()
            cursor.execute("SELECT DISTINCT Breed FROM AnimalCatalog LIMIT 50")
            basic_breeds = [row[0] for row in cursor.fetchall()]
            cursor.close()
            conn.close()
        except Exception as e:
            print(f"Could not load breed list from database: {str(e)}")
            # 後備品種清單
            basic_breeds = [
                'Labrador_Retriever', 'Golden_Retriever', 'German_Shepherd', 'French_Bulldog',
                'Border_Collie', 'Poodle', 'Beagle', 'Rottweiler', 'Yorkshire_Terrier',
                'Dachshund', 'Boxer', 'Siberian_Husky', 'Great_Dane', 'Pomeranian', 'Shih-Tzu',
                'Maltese_Dog', 'Chihuahua', 'Cavalier_King_Charles_Spaniel', 'Boston_Terrier',
                'Japanese_Spaniel', 'Toy_Terrier', 'Affenpinscher', 'Pekingese', 'Lhasa'
            ]

        for breed in basic_breeds:
            breed_info = get_dog_description(breed) or {}
            breed_text = f"{breed} {breed_info.get('Temperament', '')} {breed_info.get('Size', '')} {breed_info.get('Description', '')}".lower()

            # 計算關鍵字匹配分數
            matches = sum(1 for keyword in keywords if keyword in breed_text)
            base_score = min(0.95, 0.3 + (matches / len(keywords)) * 0.6)

            # 應用增強匹配邏輯
            enhanced_score = _calculate_enhanced_matching_score(
                breed, breed_info, user_description, base_score
            )

            breed_scores.append((breed, enhanced_score['final_score'], breed_info, enhanced_score))

        # 按分數排序
        breed_scores.sort(key=lambda x: x[1], reverse=True)

        recommendations = []
        for i, (breed, final_score, breed_info, enhanced_score) in enumerate(breed_scores[:top_k]):
            recommendation = {
                'breed': breed.replace('_', ' '),
                'rank': i + 1,
                'overall_score': final_score,
                'final_score': final_score,
                'semantic_score': enhanced_score.get('weighted_score', final_score),
                'comparative_bonus': enhanced_score.get('lifestyle_bonus', 0.0),
                'lifestyle_bonus': enhanced_score.get('lifestyle_bonus', 0.0),
                'size': breed_info.get('Size', 'Unknown'),
                'temperament': breed_info.get('Temperament', 'Unknown'),
                'exercise_needs': breed_info.get('Exercise Needs', 'Moderate'),
                'grooming_needs': breed_info.get('Grooming Needs', 'Moderate'),
                'good_with_children': breed_info.get('Good with Children', 'Unknown'),
                'lifespan': breed_info.get('Lifespan', '10-12 years'),
                'description': breed_info.get('Description', 'No description available'),
                'search_type': 'description',
                'scores': enhanced_score.get('dimension_scores', {
                    'space': final_score * 0.9,
                    'exercise': final_score * 0.85,
                    'grooming': final_score * 0.8,
                    'experience': final_score * 0.75,
                    'noise': final_score * 0.7,
                    'family': final_score * 0.65
                })
            }
            recommendations.append(recommendation)

        return recommendations

    except Exception as e:
        error_msg = f"Error in basic text matching: {str(e)}"
        print(f"ERROR: {error_msg}")
        raise RuntimeError(error_msg) from e