scoring_calculation_system.py

from dataclasses import dataclass
from breed_health_info import breed_health_info
from breed_noise_info import breed_noise_info

@dataclass
class UserPreferences:

    """使用者偏好設定的資料結構"""
    living_space: str  # "apartment", "house_small", "house_large"
    yard_access: str  # "no_yard", "shared_yard", "private_yard" 
    exercise_time: int  # minutes per day
    exercise_type: str  # "light_walks", "moderate_activity", "active_training" 
    grooming_commitment: str  # "low", "medium", "high"
    experience_level: str  # "beginner", "intermediate", "advanced"
    time_availability: str  # "limited", "moderate", "flexible" 
    has_children: bool
    children_age: str  # "toddler", "school_age", "teenager"
    noise_tolerance: str  # "low", "medium", "high"
    space_for_play: bool
    other_pets: bool
    climate: str  # "cold", "moderate", "hot"
    health_sensitivity: str = "medium"
    barking_acceptance: str = None

    def __post_init__(self):
        """在初始化後運行，用於設置派生值"""
        if self.barking_acceptance is None:
            self.barking_acceptance = self.noise_tolerance


# @staticmethod
# def calculate_breed_bonus(breed_info: dict, user_prefs: 'UserPreferences') -> float:
#     """計算品種額外加分"""
#     bonus = 0.0
#     temperament = breed_info.get('Temperament', '').lower()
    
#     # 1. 壽命加分（最高0.05）
#     try:
#         lifespan = breed_info.get('Lifespan', '10-12 years')
#         years = [int(x) for x in lifespan.split('-')[0].split()[0:1]]
#         longevity_bonus = min(0.05, (max(years) - 10) * 0.01)
#         bonus += longevity_bonus
#     except:
#         pass

#     # 2. 性格特徵加分（最高0.15）
#     positive_traits = {
#         'friendly': 0.05,           
#         'gentle': 0.05,
#         'patient': 0.05,
#         'intelligent': 0.04,
#         'adaptable': 0.04,
#         'affectionate': 0.04,
#         'easy-going': 0.03,         
#         'calm': 0.03                
#     }
    
#     negative_traits = {
#         'aggressive': -0.08,        
#         'stubborn': -0.06,
#         'dominant': -0.06,
#         'aloof': -0.04,
#         'nervous': -0.05,           
#         'protective': -0.04         
#     }
    
#     personality_score = sum(value for trait, value in positive_traits.items() if trait in temperament)
#     personality_score += sum(value for trait, value in negative_traits.items() if trait in temperament)
#     bonus += max(-0.15, min(0.15, personality_score))

#     # 3. 適應性加分（最高0.1）
#     adaptability_bonus = 0.0
#     if breed_info.get('Size') == "Small" and user_prefs.living_space == "apartment":
#         adaptability_bonus += 0.05
#     if 'adaptable' in temperament or 'versatile' in temperament:
#         adaptability_bonus += 0.05
#     bonus += min(0.1, adaptability_bonus)

#     # 4. 家庭相容性（最高0.1）
#     if user_prefs.has_children:
#         family_traits = {
#             'good with children': 0.06,  
#             'patient': 0.05,
#             'gentle': 0.05,
#             'tolerant': 0.04,           
#             'playful': 0.03             
#         }
#         unfriendly_traits = {
#             'aggressive': -0.08,        
#             'nervous': -0.07,
#             'protective': -0.06,
#             'territorial': -0.05        
#         }
        
#         # 年齡評估這樣能更細緻
#         age_adjustments = {
#             'toddler': {'bonus_mult': 0.7, 'penalty_mult': 1.3},
#             'school_age': {'bonus_mult': 1.0, 'penalty_mult': 1.0},
#             'teenager': {'bonus_mult': 1.2, 'penalty_mult': 0.8}
#         }
        
#         adj = age_adjustments.get(user_prefs.children_age, 
#                                 {'bonus_mult': 1.0, 'penalty_mult': 1.0})
        
#         family_bonus = sum(value for trait, value in family_traits.items() 
#                           if trait in temperament) * adj['bonus_mult']
#         family_penalty = sum(value for trait, value in unfriendly_traits.items() 
#                            if trait in temperament) * adj['penalty_mult']
        
#         bonus += min(0.15, max(-0.2, family_bonus + family_penalty))

    
#     # 5. 專門技能加分（最高0.1）
#     skill_bonus = 0.0
#     special_abilities = {
#         'working': 0.03,
#         'herding': 0.03,
#         'hunting': 0.03,
#         'tracking': 0.03,
#         'agility': 0.02
#     }
#     for ability, value in special_abilities.items():
#         if ability in temperament.lower():
#             skill_bonus += value
#     bonus += min(0.1, skill_bonus)

#     return min(0.5, max(-0.25, bonus))


@staticmethod
def calculate_breed_bonus(breed_info: dict, user_prefs: 'UserPreferences') -> float:
    """計算品種額外加分，強化進階使用者的評分"""
    bonus = 0.0
    temperament = breed_info.get('Temperament', '').lower()
    description = breed_info.get('Description', '').lower()
    
    # 1. 壽命加分（最高0.08）- 提高上限
    try:
        lifespan = breed_info.get('Lifespan', '10-12 years')
        years = [int(x) for x in lifespan.split('-')[0].split()[0:1]]
        longevity_bonus = min(0.08, (max(years) - 10) * 0.015)  # 提高係數
        bonus += longevity_bonus
    except:
        pass

    # 2. 性格特徵加分（最高0.20）- 提高上限
    positive_traits = {
        'friendly': 0.06,           
        'gentle': 0.06,
        'patient': 0.06,
        'intelligent': 0.05,
        'adaptable': 0.05,
        'affectionate': 0.05,
        'easy-going': 0.04,         
        'calm': 0.04                
    }
    
    # 根據經驗等級調整負面特徵的影響
    experience_multiplier = {
        'beginner': 1.3,      
        'intermediate': 0.8,
        'advanced': 0.5       # 大幅降低進階使用者的負面特徵懲罰
    }.get(user_prefs.experience_level, 1.0)
    
    negative_traits = {
        'aggressive': -0.08 * experience_multiplier,        
        'stubborn': -0.06 * experience_multiplier,
        'dominant': -0.06 * experience_multiplier,
        'aloof': -0.04 * experience_multiplier,
        'nervous': -0.05 * experience_multiplier,           
        'protective': -0.04 * experience_multiplier         
    }
    
    personality_score = sum(value for trait, value in positive_traits.items() if trait in temperament)
    if user_prefs.experience_level == 'advanced':
        personality_score *= 1.2  # 進階使用者得到更多正面特徵加分
    personality_score += sum(value for trait, value in negative_traits.items() if trait in temperament)
    bonus += max(-0.15, min(0.20, personality_score))

    # 3. 適應性加分（最高0.15）- 提高上限
    adaptability_bonus = 0.0
    if breed_info.get('Size') == "Small" and user_prefs.living_space == "apartment":
        adaptability_bonus += 0.07
    if 'adaptable' in temperament or 'versatile' in temperament:
        adaptability_bonus += 0.08
        
    # 考慮環境適應因素
    if user_prefs.yard_access == "no_yard":
        if "needs space" in description or "requires yard" in description:
            adaptability_bonus -= 0.05 * experience_multiplier  # 根據經驗調整懲罰
    elif user_prefs.yard_access == "private_yard":
        if "active" in description or "energetic" in description:
            adaptability_bonus += 0.05
            
    bonus += min(0.15, adaptability_bonus)

    # 4. 專門技能評估（最高0.15）- 提高上限和進階使用者加分
    skill_bonus = 0.0
    exercise_level = user_prefs.exercise_time / 60.0
    
    special_abilities = {
        'working': 0.05 if exercise_level >= 1.5 else 0.02,
        'herding': 0.05 if exercise_level >= 1.5 else 0.02,
        'hunting': 0.05 if exercise_level >= 1.5 else 0.02,
        'tracking': 0.04 if exercise_level >= 1.0 else 0.02,
        'agility': 0.04 if exercise_level >= 1.0 else 0.02,
        'sporting': 0.04 if exercise_level >= 1.2 else 0.02
    }
    
    for ability, value in special_abilities.items():
        if ability in temperament.lower() or ability in description:
            # 進階使用者在專門技能方面得到更多加分
            if user_prefs.experience_level == 'advanced':
                skill_bonus += value * 1.5
            elif user_prefs.experience_level == 'intermediate':
                skill_bonus += value * 1.2
            else:
                skill_bonus += value
                
    # 根據時間可用性調整技能加分
    time_multiplier = {
        'flexible': 1.2,
        'moderate': 1.0,
        'limited': 0.8
    }.get(user_prefs.time_availability, 1.0)
    
    skill_bonus *= time_multiplier
    bonus += min(0.15, skill_bonus)

    # 最終分數範圍調整，提高上限
    return min(0.6, max(-0.20, bonus))


@staticmethod
def calculate_additional_factors(breed_info: dict, user_prefs: 'UserPreferences') -> dict:
    """計算額外的評估因素"""
    factors = {
        'versatility': 0.0,        # 多功能性
        'trainability': 0.0,       # 可訓練度
        'energy_level': 0.0,       # 能量水平
        'grooming_needs': 0.0,     # 美容需求
        'social_needs': 0.0,       # 社交需求
        'weather_adaptability': 0.0 # 氣候適應性
    }
    
    temperament = breed_info.get('Temperament', '').lower()
    size = breed_info.get('Size', 'Medium')
    
    # 1. 多功能性評估
    versatile_traits = ['intelligent', 'adaptable', 'trainable', 'athletic']
    working_roles = ['working', 'herding', 'hunting', 'sporting', 'companion']
    
    trait_score = sum(0.2 for trait in versatile_traits if trait in temperament)
    role_score = sum(0.2 for role in working_roles if role in breed_info.get('Description', '').lower())
    
    factors['versatility'] = min(1.0, trait_score + role_score)
    
    # 2. 可訓練度評估
    trainable_traits = {
        'intelligent': 0.3,
        'eager to please': 0.3,
        'trainable': 0.2,
        'quick learner': 0.2
    }
    factors['trainability'] = min(1.0, sum(value for trait, value in trainable_traits.items() 
                                         if trait in temperament))
    
    # 3. 能量水平評估
    exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
    energy_levels = {
        'VERY HIGH': 1.0,
        'HIGH': 0.8,
        'MODERATE': 0.6,
        'LOW': 0.4,
        'VARIES': 0.6
    }
    factors['energy_level'] = energy_levels.get(exercise_needs, 0.6)
    
    # 4. 美容需求評估
    grooming_needs = breed_info.get('Grooming Needs', 'MODERATE').upper()
    grooming_levels = {
        'HIGH': 1.0,
        'MODERATE': 0.6,
        'LOW': 0.3
    }
    coat_penalty = 0.2 if any(term in breed_info.get('Description', '').lower() 
                             for term in ['long coat', 'double coat']) else 0
    factors['grooming_needs'] = min(1.0, grooming_levels.get(grooming_needs, 0.6) + coat_penalty)
    
    # 5. 社交需求評估
    social_traits = ['friendly', 'social', 'affectionate', 'people-oriented']
    antisocial_traits = ['independent', 'aloof', 'reserved']
    
    social_score = sum(0.25 for trait in social_traits if trait in temperament)
    antisocial_score = sum(-0.2 for trait in antisocial_traits if trait in temperament)
    factors['social_needs'] = min(1.0, max(0.0, social_score + antisocial_score))
    
    # 6. 氣候適應性評估
    climate_terms = {
        'cold': ['thick coat', 'winter', 'cold climate'],
        'hot': ['short coat', 'warm climate', 'heat tolerant'],
        'moderate': ['adaptable', 'all climate']
    }
    
    climate_matches = sum(1 for term in climate_terms[user_prefs.climate] 
                        if term in breed_info.get('Description', '').lower())
    factors['weather_adaptability'] = min(1.0, climate_matches * 0.3 + 0.4)  # 基礎分0.4

    return factors


@staticmethod
def calculate_family_safety_score(breed_info: dict, children_age: str) -> float:
    """
    計算品種與家庭/兒童的安全相容性分數，作為calculate_compatibility_score的一部分
    
    參數:
    breed_info (dict): 品種資訊
    children_age (str): 兒童年齡組別 ('toddler', 'school_age', 'teenager')
    
    返回:
    float: 0.2-0.95之間的安全分數
    """
    temperament = breed_info.get('Temperament', '').lower()
    size = breed_info.get('Size', 'Medium')
    
    # 基礎安全分數（根據體型）
    base_safety_scores = {
        "Small": 0.85,    
        "Medium": 0.75,   
        "Large": 0.65,    
        "Giant": 0.55     
    }
    safety_score = base_safety_scores.get(size, 0.70)
    
    # 年齡相關的調整
    age_factors = {
        'toddler': {
            'base_modifier': -0.15,
            'size_penalty': {
                "Small": -0.05,
                "Medium": -0.10,
                "Large": -0.20,
                "Giant": -0.25
            }
        },
        'school_age': {
            'base_modifier': -0.08,
            'size_penalty': {
                "Small": -0.02,
                "Medium": -0.05,
                "Large": -0.10,
                "Giant": -0.15
            }
        },
        'teenager': {
            'base_modifier': -0.05,
            'size_penalty': {
                "Small": 0,
                "Medium": -0.02,
                "Large": -0.05,
                "Giant": -0.08
            }
        }
    }
    
    # 應用年齡相關調整
    age_adjustment = age_factors.get(children_age, age_factors['school_age'])
    safety_score += age_adjustment['base_modifier']
    safety_score += age_adjustment['size_penalty'].get(size, -0.10)
    
    # 正面特徵評估
    positive_traits = {
        'gentle': 0.10,
        'patient': 0.10,
        'good with children': 0.15,
        'friendly': 0.08,
        'calm': 0.08,
        'tolerant': 0.08,
        'playful': 0.05
    }
    
    # 危險特徵評估（更嚴格的懲罰）
    dangerous_traits = {
        'aggressive': -0.25,
        'territorial': -0.20,
        'protective': -0.15,
        'nervous': -0.15,
        'dominant': -0.15,
        'strong-willed': -0.12,
        'independent': -0.10,
        'energetic': -0.08
    }
    
    # 計算特徵分數
    for trait, bonus in positive_traits.items():
        if trait in temperament:
            safety_score += bonus * 0.8  # 降低正面特徵的影響力
            
    for trait, penalty in dangerous_traits.items():
        if trait in temperament:
            # 對幼童加重懲罰
            if children_age == 'toddler':
                safety_score += penalty * 1.3
            # 對青少年略微減輕懲罰
            elif children_age == 'teenager':
                safety_score += penalty * 0.8
            else:
                safety_score += penalty
    
    # 特殊風險評估
    description = breed_info.get('Description', '').lower()
    if 'history of' in description:
        safety_score -= 0.15
    if 'requires experienced' in description:
        safety_score -= 0.10
    
    # 將分數限制在合理範圍內
    return max(0.2, min(0.95, safety_score))


def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences) -> dict:
    """計算品種與使用者條件的相容性分數的優化版本"""
    try:
        print(f"Processing breed: {breed_info.get('Breed', 'Unknown')}")
        print(f"Breed info keys: {breed_info.keys()}")
        
        if 'Size' not in breed_info:
            print("Missing Size information")
            raise KeyError("Size information missing")
            
        def calculate_space_score(size: str, living_space: str, has_yard: bool, exercise_needs: str) -> float:
            """空間分數計算"""
            # 基礎空間需求矩陣
            base_scores = {
                "Small": {"apartment": 0.95, "house_small": 1.0, "house_large": 0.90},
                "Medium": {"apartment": 0.60, "house_small": 0.90, "house_large": 1.0},
                "Large": {"apartment": 0.30, "house_small": 0.75, "house_large": 1.0},
                "Giant": {"apartment": 0.15, "house_small": 0.55, "house_large": 1.0}
            }
            
            # 取得基礎分數
            base_score = base_scores.get(size, base_scores["Medium"])[living_space]
            
            # 運動需求調整
            exercise_adjustments = {
                "Very High": -0.15 if living_space == "apartment" else 0,
                "High": -0.10 if living_space == "apartment" else 0,
                "Moderate": 0,
                "Low": 0.05 if living_space == "apartment" else 0
            }
            
            adjustments = exercise_adjustments.get(exercise_needs.strip(), 0)
            
            # 院子獎勵
            if has_yard and size in ["Large", "Giant"]:
                adjustments += 0.10
            elif has_yard:
                adjustments += 0.05
                
            return min(1.0, max(0.1, base_score + adjustments))

        def calculate_exercise_score(breed_needs: str, user_time: int) -> float:
            """運動需求計算"""
            exercise_needs = {
                'VERY HIGH': {'min': 120, 'ideal': 150, 'max': 180},
                'HIGH': {'min': 90, 'ideal': 120, 'max': 150},
                'MODERATE': {'min': 45, 'ideal': 60, 'max': 90},
                'LOW': {'min': 20, 'ideal': 30, 'max': 45},
                'VARIES': {'min': 30, 'ideal': 60, 'max': 90}
            }
            
            breed_need = exercise_needs.get(breed_needs.strip().upper(), exercise_needs['MODERATE'])
            
            # 計算匹配度
            if user_time >= breed_need['ideal']:
                if user_time > breed_need['max']:
                    return 0.9  # 稍微降分，因為可能過度運動
                return 1.0
            elif user_time >= breed_need['min']:
                return 0.8 + (user_time - breed_need['min']) / (breed_need['ideal'] - breed_need['min']) * 0.2
            else:
                return max(0.3, 0.8 * (user_time / breed_need['min']))

        def calculate_grooming_score(breed_needs: str, user_commitment: str, breed_size: str) -> float:
            """美容需求計算"""
            # 基礎分數矩陣
            base_scores = {
                "High": {"low": 0.3, "medium": 0.7, "high": 1.0},
                "Moderate": {"low": 0.5, "medium": 0.9, "high": 1.0},
                "Low": {"low": 1.0, "medium": 0.95, "high": 0.8}
            }
            
            # 取得基礎分數
            base_score = base_scores.get(breed_needs, base_scores["Moderate"])[user_commitment]
            
            # 體型影響調整
            size_adjustments = {
                "Large": {"low": -0.2, "medium": -0.1, "high": 0},
                "Giant": {"low": -0.3, "medium": -0.15, "high": 0},
            }
            
            if breed_size in size_adjustments:
                adjustment = size_adjustments[breed_size].get(user_commitment, 0)
                base_score = max(0.2, base_score + adjustment)
                
            return base_score
            

        # def calculate_experience_score(care_level: str, user_experience: str, temperament: str) -> float:
        #     """
        #     計算使用者經驗與品種需求的匹配分數
            
        #     參數說明:
        #     care_level: 品種的照顧難度 ("High", "Moderate", "Low")
        #     user_experience: 使用者經驗等級 ("beginner", "intermediate", "advanced") 
        #     temperament: 品種的性格特徵描述
            
        #     返回:
        #     float: 0.2-1.0 之間的匹配分數
        #     """
        #     # 基礎分數矩陣 - 更大的分數差異來反映經驗重要性
        #     base_scores = {
        #         "High": {
        #             "beginner": 0.12,     # 降低起始分，反映高難度品種對新手的挑戰
        #             "intermediate": 0.65,  # 中級玩家可以應付，但仍有改善空間
        #             "advanced": 1.0       # 資深者能完全勝任
        #         },
        #         "Moderate": {
        #             "beginner": 0.35,    # 適中難度對新手來說仍具挑戰
        #             "intermediate": 0.82, # 中級玩家有很好的勝任能力
        #             "advanced": 1.0      # 資深者完全勝任
        #         },
        #         "Low": {
        #             "beginner": 0.72,    # 低難度品種適合新手
        #             "intermediate": 0.92, # 中級玩家幾乎完全勝任
        #             "advanced": 1.0      # 資深者完全勝任
        #         }
        #     }
            
        #     # 取得基礎分數
        #     score = base_scores.get(care_level, base_scores["Moderate"])[user_experience]
            
        #     # 性格特徵評估 - 根據經驗等級調整權重
        #     temperament_lower = temperament.lower()
        #     temperament_adjustments = 0.0
            
        #     if user_experience == "beginner":
        #         # 新手不適合的特徵 - 更嚴格的懲罰
        #         difficult_traits = {
        #             'stubborn': -0.15,      # 加重固執的懲罰
        #             'independent': -0.12,    # 加重獨立性的懲罰
        #             'dominant': -0.12,       # 加重支配性的懲罰
        #             'strong-willed': -0.10,  # 加重強勢的懲罰
        #             'protective': -0.08,     # 加重保護性的懲罰
        #             'aloof': -0.08,         # 加重冷漠的懲罰
        #             'energetic': -0.06      # 輕微懲罰高能量
        #         }
                
        #         # 新手友善的特徵 - 提供更多獎勵
        #         easy_traits = {
        #             'gentle': 0.08,          # 增加溫和的獎勵
        #             'friendly': 0.08,        # 增加友善的獎勵
        #             'eager to please': 0.08, # 增加順從的獎勵
        #             'patient': 0.06,         # 獎勵耐心
        #             'adaptable': 0.06,       # 獎勵適應性
        #             'calm': 0.05            # 獎勵冷靜
        #         }
                
        #         # 計算特徵調整
        #         for trait, penalty in difficult_traits.items():
        #             if trait in temperament_lower:
        #                 temperament_adjustments += penalty * 1.2  # 加重新手的懲罰
                
        #         for trait, bonus in easy_traits.items():
        #             if trait in temperament_lower:
        #                 temperament_adjustments += bonus
                        
        #         # 品種特殊調整
        #         if any(term in temperament_lower for term in ['terrier', 'working', 'guard']):
        #             temperament_adjustments -= 0.12  # 加重對特定類型品種的懲罰
                    
        #     elif user_experience == "intermediate":
        #         # 中級玩家的調整更加平衡
        #         moderate_traits = {
        #             'intelligent': 0.05,     # 獎勵聰明
        #             'athletic': 0.04,        # 獎勵運動能力
        #             'versatile': 0.04,       # 獎勵多功能性
        #             'stubborn': -0.06,       # 輕微懲罰固執
        #             'independent': -0.05,    # 輕微懲罰獨立性
        #             'protective': -0.04      # 輕微懲罰保護性
        #         }
                
        #         for trait, adjustment in moderate_traits.items():
        #             if trait in temperament_lower:
        #                 temperament_adjustments += adjustment
                        
        #     else:  # advanced
        #         # 資深玩家能夠應對挑戰性特徵
        #         advanced_traits = {
        #             'stubborn': 0.04,        # 反轉為優勢
        #             'independent': 0.04,      # 反轉為優勢
        #             'intelligent': 0.05,      # 獎勵聰明
        #             'protective': 0.04,       # 獎勵保護性
        #             'strong-willed': 0.03    # 獎勵強勢
        #         }
                
        #         for trait, bonus in advanced_traits.items():
        #             if trait in temperament_lower:
        #                 temperament_adjustments += bonus
            
        #     # 確保最終分數在合理範圍內
        #     final_score = max(0.2, min(1.0, score + temperament_adjustments))
        #     return final_score

        def calculate_experience_score(care_level: str, user_experience: str, temperament: str) -> float:
            """
            計算使用者經驗與品種需求的匹配分數，強化進階使用者的評分
            """
            # 調整基礎分數矩陣，提高 advanced 的基本分數
            base_scores = {
                "High": {
                    "beginner": 0.35,
                    "intermediate": 0.75,
                    "advanced": 0.92    # 提高上限
                },
                "Moderate": {
                    "beginner": 0.45,
                    "intermediate": 0.82,
                    "advanced": 0.95
                },
                "Low": {
                    "beginner": 0.60,
                    "intermediate": 0.85,
                    "advanced": 0.98
                }
            }
            
            score = base_scores.get(care_level, base_scores["Moderate"])[user_experience]
            
            # 性格特徵評估
            temperament_lower = temperament.lower()
            temperament_adjustments = 0.0
            
            if user_experience == "advanced":
                # 進階使用者的特徵評估
                advanced_traits = {
                    'intelligent': 0.08,       # 提高正面特徵加分
                    'independent': 0.06,
                    'strong-willed': 0.05,
                    'energetic': 0.05,
                    'protective': 0.04,
                    'dominant': -0.02,         # 降低負面特徵懲罰
                    'stubborn': -0.02,
                    'aggressive': -0.05
                }
                
                for trait, adjustment in advanced_traits.items():
                    if trait in temperament_lower:
                        temperament_adjustments += adjustment
                        
            elif user_experience == "intermediate":
                moderate_traits = {
                    'intelligent': 0.05,
                    'adaptable': 0.04,
                    'easy-going': 0.04,
                    'stubborn': -0.06,
                    'independent': -0.05,
                    'dominant': -0.05,
                    'aggressive': -0.08
                }
                
                for trait, adjustment in moderate_traits.items():
                    if trait in temperament_lower:
                        temperament_adjustments += adjustment
            
            else:  # beginner
                beginner_traits = {
                    'gentle': 0.05,
                    'friendly': 0.05,
                    'easy-going': 0.04,
                    'stubborn': -0.10,
                    'independent': -0.08,
                    'dominant': -0.08,
                    'aggressive': -0.12
                }
                
                for trait, adjustment in beginner_traits.items():
                    if trait in temperament_lower:
                        temperament_adjustments += adjustment
            
            # 特殊能力評估 - 對進階使用者加分
            if user_experience == "advanced":
                special_abilities = {
                    'working': 0.04,
                    'hunting': 0.04,
                    'herding': 0.04,
                    'guard': 0.03,
                    'agility': 0.03
                }
                
                for ability, bonus in special_abilities.items():
                    if ability in temperament_lower:
                        temperament_adjustments += bonus
            
            # 確保最終分數在合理範圍內
            final_score = max(0.3, min(0.98, score + temperament_adjustments))
            return final_score

        def calculate_health_score(breed_name: str) -> float:
            """計算品種健康分數"""
            if breed_name not in breed_health_info:
                return 0.5

            health_notes = breed_health_info[breed_name]['health_notes'].lower()
            
            # 嚴重健康問題（降低0.15分）
            severe_conditions = [
                'hip dysplasia',
                'heart disease',
                'progressive retinal atrophy',
                'bloat',
                'epilepsy',
                'degenerative myelopathy',
                'von willebrand disease'
            ]
            
            # 中度健康問題（降低0.1分）
            moderate_conditions = [
                'allergies',
                'eye problems',
                'joint problems',
                'hypothyroidism',
                'ear infections',
                'skin issues'
            ]
            
            # 輕微健康問題（降低0.05分）
            minor_conditions = [
                'dental issues',
                'weight gain tendency',
                'minor allergies',
                'seasonal allergies'
            ]

            # 計算基礎健康分數
            health_score = 1.0
            
            # 根據問題嚴重程度扣分
            severe_count = sum(1 for condition in severe_conditions if condition in health_notes)
            moderate_count = sum(1 for condition in moderate_conditions if condition in health_notes)
            minor_count = sum(1 for condition in minor_conditions if condition in health_notes)
            
            health_score -= (severe_count * 0.15)
            health_score -= (moderate_count * 0.1)
            health_score -= (minor_count * 0.05)

            # 壽命影響
            try:
                lifespan = breed_health_info[breed_name].get('average_lifespan', '10-12')
                years = float(lifespan.split('-')[0])
                if years < 8:
                    health_score *= 0.9
                elif years > 13:
                    health_score *= 1.1
            except:
                pass

            # 特殊健康優勢
            if 'generally healthy' in health_notes or 'hardy breed' in health_notes:
                health_score *= 1.1

            return max(0.2, min(1.0, health_score))

        def calculate_noise_score(breed_name: str, user_noise_tolerance: str) -> float:
            """計算品種噪音分數"""
            if breed_name not in breed_noise_info:
                return 0.5

            noise_info = breed_noise_info[breed_name]
            noise_level = noise_info['noise_level'].lower()
            noise_notes = noise_info['noise_notes'].lower()

            # 基礎噪音分數矩陣
            base_scores = {
                'low': {'low': 1.0, 'medium': 0.9, 'high': 0.8},
                'medium': {'low': 0.7, 'medium': 1.0, 'high': 0.9},
                'high': {'low': 0.4, 'medium': 0.7, 'high': 1.0},
                'varies': {'low': 0.6, 'medium': 0.8, 'high': 0.9}
            }

            # 獲取基礎分數
            base_score = base_scores.get(noise_level, {'low': 0.7, 'medium': 0.8, 'high': 0.6})[user_noise_tolerance]

            # 吠叫原因評估
            barking_reasons_penalty = 0
            problematic_triggers = [
                ('separation anxiety', -0.15),
                ('excessive barking', -0.12),
                ('territorial', -0.08),
                ('alert barking', -0.05),
                ('attention seeking', -0.05)
            ]

            for trigger, penalty in problematic_triggers:
                if trigger in noise_notes:
                    barking_reasons_penalty += penalty

            # 可訓練性補償
            trainability_bonus = 0
            if 'responds well to training' in noise_notes:
                trainability_bonus = 0.1
            elif 'can be trained' in noise_notes:
                trainability_bonus = 0.05

            # 特殊情況
            special_adjustments = 0
            if 'rarely barks' in noise_notes:
                special_adjustments += 0.1
            if 'howls' in noise_notes and user_noise_tolerance == 'low':
                special_adjustments -= 0.1

            final_score = base_score + barking_reasons_penalty + trainability_bonus + special_adjustments
            
            return max(0.2, min(1.0, final_score))

        # 計算所有基礎分數
        scores = {
            'space': calculate_space_score(
                breed_info['Size'], 
                user_prefs.living_space,
                user_prefs.space_for_play,
                breed_info.get('Exercise Needs', 'Moderate')
            ),
            'exercise': calculate_exercise_score(
                breed_info.get('Exercise Needs', 'Moderate'),
                user_prefs.exercise_time
            ),
            'grooming': calculate_grooming_score(
                breed_info.get('Grooming Needs', 'Moderate'),
                user_prefs.grooming_commitment.lower(),
                breed_info['Size']
            ),
            'experience': calculate_experience_score(
                breed_info.get('Care Level', 'Moderate'),
                user_prefs.experience_level,
                breed_info.get('Temperament', '')
            ),
            'health': calculate_health_score(breed_info.get('Breed', '')),
            'noise': calculate_noise_score(breed_info.get('Breed', ''), user_prefs.noise_tolerance)
        }

        breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
        scores['breed_bonus'] = breed_bonus
        
        # 如果有小孩，加入 family_safety 分數
        if user_prefs.has_children:
            scores['family_safety'] = calculate_family_safety_score(breed_info, user_prefs.children_age)
            

        # 優化權重配置
        weights = {
            'space': 0.28,      
            'exercise': 0.18,   
            'grooming': 0.12,   
            'experience': 0.22, 
            'health': 0.12,     
            'noise': 0.08      
        }

        if user_prefs.has_children:          
            weights = {
                'space': 0.20,
                'exercise': 0.13,
                'grooming': 0.08,
                'experience': 0.15,
                'health': 0.10,
                'noise': 0.06,
                'breed_bonus': 0.08,
                'family_safety': 0.20  # 給予家庭安全較高權重
            }

        # 計算加權總分
        weighted_score = sum(score * weights[category] for category, score in scores.items())

        # def amplify_score(score):
        #     """
        #     優化分數放大函數，確保分數範圍合理且結果一致
        #     """
        #     # 基礎調整
        #     adjusted = (score - 0.35) * 1.8
            
        #     # 使用 3.2 次方使曲線更平滑
        #     amplified = pow(adjusted, 3.2) / 5.8 + score
            
        #     # 特別處理高分區間，確保不超過95%
        #     if amplified > 0.90:
        #         # 壓縮高分區間，確保最高到95%
        #         amplified = 0.90 + (amplified - 0.90) * 0.5
            
        #     # 確保最終分數在合理範圍內（0.55-0.95）
        #     final_score = max(0.55, min(0.95, amplified))
            
        #     # 四捨五入到小數點後第三位
        #     return round(final_score, 3)
        
        # final_score = amplify_score(weighted_score)

        # # 四捨五入所有分數
        # scores = {k: round(v, 4) for k, v in scores.items()}
        # scores['overall'] = round(final_score, 4)

        # return scores

        def amplify_score(score):
            """
            優化分數放大函數，確保更合理的分數分布和品種間的差異
            
            1. 調整基礎計算係數，使分數差異更明顯
            2. 重新設計高分區間的處理
            3. 確保進階使用者能獲得更高分數
            4. 維持適當的分數下限
            """
            # 第一階段：基礎調整
            # 降低基礎調整係數，使分數變化更平滑
            adjusted = (score - 0.30) * 1.5
            
            # 第二階段：非線性轉換
            # 使用較小的指數，讓分數差異更明顯
            amplified = pow(adjusted, 2.8) / 4.2 + score
            
            # 第三階段：分數區間處理
            if amplified > 0.85:
                # 高分區間的處理更細緻
                extra = (amplified - 0.85)
                amplified = 0.85 + extra * 0.6
            elif amplified < 0.65:
                # 低分區間給予適當提升
                boost = (0.65 - amplified) * 0.3
                amplified += boost
                
            # 第四階段：確保分數在合理範圍內
            # 提高最低分數，降低最高分數
            final_score = max(0.60, min(0.92, amplified))
            
            # 第五階段：微調
            # 讓分數更容易落在中間區間
            if 0.75 <= final_score <= 0.85:
                variance = (random.random() - 0.5) * 0.02
                final_score += variance
            
            # 確保最終分數在絕對範圍內
            final_score = max(0.60, min(0.92, final_score))
            
            return round(final_score, 3)

    except Exception as e:
        print(f"Error details: {str(e)}")
        print(f"breed_info: {breed_info}")
        # print(f"Error in calculate_compatibility_score: {str(e)}")
        return {k: 0.5 for k in ['space', 'exercise', 'grooming', 'experience', 'health', 'noise', 'overall']}