Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -5,28 +5,67 @@ import traceback
 import math
 import random
 
+# @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
+
 @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" 
+    """使用者偏好設定的資料結構，整合基本條件與進階評估參數"""
+    # 基礎居住條件
+    living_space: str        # "apartment", "house_small", "house_large"
+    yard_access: str        # "no_yard", "shared_yard", "private_yard"
+    living_floor: int = 1   # 居住樓層，對公寓住戶特別重要
+    
+    # 運動相關參數
+    exercise_time: int      # 每日運動時間（分鐘）
+    exercise_type: str      # "light_walks", "moderate_activity", "active_training"
+    exercise_intensity: str = "moderate"  # "low", "moderate", "high"
+    
+    # 照護能力與時間
+    grooming_commitment: str    # "low", "medium", "high"
+    experience_level: str       # "beginner", "intermediate", "advanced"
+    time_availability: str      # "limited", "moderate", "flexible"
+    home_alone_time: int = 4    # 每日獨處時間（小時）
+    
+    # 家庭環境
     has_children: bool
-    children_age: str  # "toddler", "school_age", "teenager"
-    noise_tolerance: str  # "low", "medium", "high"
-    space_for_play: bool
+    children_age: str       # "toddler", "school_age", "teenager"
     other_pets: bool
-    climate: str  # "cold", "moderate", "hot"
-    health_sensitivity: str = "medium"
-    barking_acceptance: str = None
+    
+    # 環境適應性
+    noise_tolerance: str    # "low", "medium", "high"
+    space_for_play: bool
+    climate: str           # "cold", "moderate", "hot"
+    
+    # 特殊需求
+    health_sensitivity: str = "medium"    # "low", "medium", "high"
+    barking_acceptance: str = None        # 如果未指定，默認使用 noise_tolerance
+    lifestyle_activity: str = "moderate"  # "sedentary", "moderate", "active"
 
     def __post_init__(self):
-        """在初始化後運行，用於設置派生值"""
+        """初始化後執行，用於設置派生值和驗證"""
         if self.barking_acceptance is None:
             self.barking_acceptance = self.noise_tolerance
 
@@ -157,242 +196,7 @@ def calculate_breed_bonus(breed_info: dict, user_prefs: 'UserPreferences') -> fl
     bonus += min(0.15, adaptability_bonus)
 
     return min(0.5, max(-0.25, bonus))
-
-
-# @staticmethod
-# def calculate_breed_bonus(breed_info: dict, user_prefs: UserPreferences) -> float:
-#     """
-#     計算品種的額外加分，評估品種的特殊特徵對使用者需求的適配性。
-    
-#     這個函數考慮四個主要面向：
-#     1. 壽命評估：考慮飼養的長期承諾
-#     2. 性格特徵評估：評估品種性格與使用者需求的匹配度
-#     3. 環境適應性：評估品種在特定生活環境中的表現
-#     4. 家庭相容性：特別關注品種與家庭成員的互動
-#     """
-#     bonus = 0.0
-#     temperament = breed_info.get('Temperament', '').lower()
-#     description = breed_info.get('Description', '').lower()
-    
-#     # 壽命評估 - 重新設計以反映更實際的考量
-#     try:
-#         lifespan = breed_info.get('Lifespan', '10-12 years')
-#         years = [int(x) for x in lifespan.split('-')[0].split()[0:1]]
-#         avg_years = float(years[0])
-        
-#         # 根據壽命長短給予不同程度的獎勵或懲罰
-#         if avg_years < 8:
-#             bonus -= 0.08  # 短壽命可能帶來情感負擔
-#         elif avg_years < 10:
-#             bonus -= 0.04  # 稍短壽命輕微降低評分
-#         elif avg_years > 13:
-#             bonus += 0.06  # 長壽命適度加分
-#         elif avg_years > 15:
-#             bonus += 0.08  # 特別長壽的品種獲得更多加分
-#     except:
-#         pass
-
-#     # 性格特徵評估 - 擴充並細化評分標準
-#     positive_traits = {
-#         'friendly': 0.08,           # 提高友善性的重要性
-#         'gentle': 0.08,            # 溫和性格更受歡迎
-#         'patient': 0.07,           # 耐心是重要特質
-#         'intelligent': 0.06,        # 聰明但不過分重要
-#         'adaptable': 0.06,         # 適應性佳的特質
-#         'affectionate': 0.06,      # 親密性很重要
-#         'easy-going': 0.05,        # 容易相處的性格
-#         'calm': 0.05              # 冷靜的特質
-#     }
-    
-#     negative_traits = {
-#         'aggressive': -0.15,       # 嚴重懲罰攻擊性
-#         'stubborn': -0.10,        # 固執性格不易處理
-#         'dominant': -0.10,        # 支配性可能造成問題
-#         'aloof': -0.08,          # 冷漠性格影響互動
-#         'nervous': -0.08,         # 緊張性格需要更多關注
-#         'protective': -0.06       # 過度保護可能有風險
-#     }
-    
-#     # 性格評分計算 - 加入累積效應
-#     personality_score = 0
-#     positive_count = 0
-#     negative_count = 0
-    
-#     for trait, value in positive_traits.items():
-#         if trait in temperament:
-#             personality_score += value
-#             positive_count += 1
-            
-#     for trait, value in negative_traits.items():
-#         if trait in temperament:
-#             personality_score += value
-#             negative_count += 1
     
-#     # 多重特徵的累積效應
-#     if positive_count > 2:
-#         personality_score *= (1 + (positive_count - 2) * 0.1)
-#     if negative_count > 1:
-#         personality_score *= (1 - (negative_count - 1) * 0.15)
-    
-#     bonus += max(-0.25, min(0.25, personality_score))
-
-#     # 適應性評估 - 根據具體環境給予更細緻的評分
-#     adaptability_bonus = 0.0
-#     if breed_info.get('Size') == "Small" and user_prefs.living_space == "apartment":
-#         adaptability_bonus += 0.08  # 小型犬更適合公寓
-    
-#     # 環境適應性評估
-#     if 'adaptable' in temperament or 'versatile' in temperament:
-#         if user_prefs.living_space == "apartment":
-#             adaptability_bonus += 0.10  # 適應性在公寓環境更重要
-#         else:
-#             adaptability_bonus += 0.05  # 其他環境仍有加分
-            
-#     # 氣候適應性
-#     description = breed_info.get('Description', '').lower()
-#     climate = user_prefs.climate
-#     if climate == 'hot':
-#         if 'heat tolerant' in description or 'warm climate' in description:
-#             adaptability_bonus += 0.08
-#         elif 'thick coat' in description or 'cold climate' in description:
-#             adaptability_bonus -= 0.10
-#     elif climate == 'cold':
-#         if 'thick coat' in description or 'cold climate' in description:
-#             adaptability_bonus += 0.08
-#         elif 'heat tolerant' in description or 'short coat' in description:
-#             adaptability_bonus -= 0.10
-            
-#     bonus += min(0.15, adaptability_bonus)
-
-#     # 家庭相容性評估 - 特別關注有孩童的家庭
-#     if user_prefs.has_children:
-#         family_traits = {
-#             'good with children': 0.12,  # 提高與孩童相處的重要性
-#             'patient': 0.10,
-#             'gentle': 0.10,
-#             'tolerant': 0.08,
-#             'playful': 0.06
-#         }
-        
-#         unfriendly_traits = {
-#             'aggressive': -0.15,       # 加重攻擊性的懲罰
-#             'nervous': -0.12,         # 緊張特質可能有風險
-#             'protective': -0.10,      # 過度保護性需要注意
-#             'territorial': -0.08      # 地域性可能造成問題
-#         }
-        
-#         # 根據孩童年齡調整評分權重
-#         age_adjustments = {
-#             'toddler': {
-#                 'bonus_mult': 0.6,    # 降低正面特質的獎勵
-#                 'penalty_mult': 1.5    # 加重負面特質的懲罰
-#             },
-#             '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_score = 0
-#         for trait, value in family_traits.items():
-#             if trait in temperament:
-#                 family_score += value * adj['bonus_mult']
-                
-#         for trait, value in unfriendly_traits.items():
-#             if trait in temperament:
-#                 family_score += value * adj['penalty_mult']
-        
-#         bonus += min(0.20, max(-0.30, family_score))
-
-#     # 確保總體加分在合理範圍內，但允許更大的變化
-#     return min(0.5, max(-0.35, 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_additional_factors(breed_info: dict, user_prefs: 'UserPreferences') -> dict:
@@ -653,37 +457,43 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             
 
         # def calculate_space_score(size: str, living_space: str, has_yard: bool, exercise_needs: str) -> float:
-        #     # 重新設計基礎分數矩陣
+        #     """       
+        #     主要改進：
+        #     1. 更均衡的基礎分數分配
+        #     2. 更細緻的空間需求評估
+        #     3. 強化運動需求與空間的關聯性
+        #     """
+        #     # 重新設計基礎分數矩陣，降低普遍分數以增加區別度
         #     base_scores = {
         #         "Small": {
-        #             "apartment": 1.0,      # 小型犬最適合公寓
-        #             "house_small": 0.95,   # 在大房子反而稍微降分
-        #             "house_large": 0.85    # 可能浪費空間
+        #             "apartment": 0.85,    # 降低滿分機會
+        #             "house_small": 0.80,  # 小型犬不應在大空間得到太高分數
+        #             "house_large": 0.75   # 避免小型犬總是得到最高分
         #         },
         #         "Medium": {
-        #             "apartment": 0.45,     # 中型犬在公寓明顯受限
-        #             "house_small": 0.85,
-        #             "house_large": 1.0
+        #             "apartment": 0.45,    # 維持對公寓環境的限制
+        #             "house_small": 0.75,  # 適中的分數
+        #             "house_large": 0.85   # 給予合理的獎勵
         #         },
         #         "Large": {
-        #             "apartment": 0.15,     # 大型犬在公寓極不適合
-        #             "house_small": 0.60,   # 在小房子仍然受限
-        #             "house_large": 1.0
+        #             "apartment": 0.15,    # 加重對大型犬在公寓的限制
+        #             "house_small": 0.65,  # 中等適合度
+        #             "house_large": 0.90   # 最適合的環境
         #         },
         #         "Giant": {
-        #             "apartment": 0.1,      # 更嚴格的限制
-        #             "house_small": 0.45,
-        #             "house_large": 1.0
+        #             "apartment": 0.10,    # 更嚴格的限制
+        #             "house_small": 0.45,  # 顯著的空間限制
+        #             "house_large": 0.95   # 最理想的配對
         #         }
         #     }
             
         #     # 取得基礎分數
         #     base_score = base_scores.get(size, base_scores["Medium"])[living_space]
             
-        #     # 運動需求調整更明顯
+        #     # 運動需求相關的調整更加動態
         #     exercise_adjustments = {
         #         "Very High": {
-        #             "apartment": -0.25,    # 在公寓更嚴重的懲罰
+        #             "apartment": -0.25,    # 加重在受限空間的懲罰
         #             "house_small": -0.15,
         #             "house_large": -0.05
         #         },
@@ -698,250 +508,352 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
         #             "house_large": 0
         #         },
         #         "Low": {
-        #             "apartment": 0.05,
+        #             "apartment": 0.05,     # 低運動需求在小空間反而有優勢
         #             "house_small": 0,
-        #             "house_large": 0
+        #             "house_large": -0.05   # 輕微降低評分，因為空間可能過大
         #         }
         #     }
             
-        #     # 根據空間類型獲取對應的運動調整
+        #     # 根據空間類型獲取運動需求調整
         #     adjustment = exercise_adjustments.get(exercise_needs, 
         #                                         exercise_adjustments["Moderate"])[living_space]
             
-        #     # 院子獎勵也要根據犬種大小調整
-        #     yard_bonus = 0
+        #     # 院子效益根據品種大小和運動需求動態調整
         #     if has_yard:
-        #         if size in ["Large", "Giant"]:
-        #             yard_bonus = 0.20 if living_space != "apartment" else 0.10
-        #         elif size == "Medium":
-        #             yard_bonus = 0.15 if living_space != "apartment" else 0.08
-        #         else:
-        #             yard_bonus = 0.10 if living_space != "apartment" else 0.05
+        #         yard_bonus = {
+        #             "Giant": 0.20,
+        #             "Large": 0.15,
+        #             "Medium": 0.10,
+        #             "Small": 0.05
+        #         }.get(size, 0.10)
+                
+        #         # 運動需求會影響院子的重要性
+        #         if exercise_needs in ["Very High", "High"]:
+        #             yard_bonus *= 1.2
+        #         elif exercise_needs == "Low":
+        #             yard_bonus *= 0.8
                     
-        #     final_score = base_score + adjustment + yard_bonus
-        #     return min(1.0, max(0.1, final_score))
+        #         current_score = base_score + adjustment + yard_bonus
+        #     else:
+        #         current_score = base_score + adjustment
+                
+        #     # 確保分數在合理範圍內，但避免極端值
+        #     return min(0.95, max(0.15, current_score))
 
 
-        def calculate_space_score(size: str, living_space: str, has_yard: bool, exercise_needs: str) -> float:
+        # def calculate_exercise_score(breed_needs: str, exercise_time: int, exercise_type: str) -> float:
+        #     """
+        #     精確評估品種運動需求與使用者運動條件的匹配度
+            
+        #     Parameters:
+        #     breed_needs: 品種的運動需求等級
+        #     exercise_time: 使用者能提供的運動時間（分鐘）
+        #     exercise_type: 使用者偏好的運動類型
+            
+        #     Returns:
+        #     float: -0.2 到 0.2 之間的匹配分數
+        #     """
+        #     # 定義更細緻的運動需求等級
+        #     exercise_levels = {
+        #         'VERY HIGH': {
+        #             'min': 120,
+        #             'ideal': 150,
+        #             'max': 180,
+        #             'intensity': 'high',
+        #             'sessions': 'multiple',
+        #             'preferred_types': ['active_training', 'intensive_exercise']
+        #         },
+        #         'HIGH': {
+        #             'min': 90,
+        #             'ideal': 120,
+        #             'max': 150,
+        #             'intensity': 'moderate_high',
+        #             'sessions': 'multiple',
+        #             'preferred_types': ['active_training', 'moderate_activity']
+        #         },
+        #         'MODERATE HIGH': {
+        #             'min': 70,
+        #             'ideal': 90,
+        #             'max': 120,
+        #             'intensity': 'moderate',
+        #             'sessions': 'flexible',
+        #             'preferred_types': ['moderate_activity', 'active_training']
+        #         },
+        #         'MODERATE': {
+        #             'min': 45,
+        #             'ideal': 60,
+        #             'max': 90,
+        #             'intensity': 'moderate',
+        #             'sessions': 'flexible',
+        #             'preferred_types': ['moderate_activity', 'light_walks']
+        #         },
+        #         'MODERATE LOW': {
+        #             'min': 30,
+        #             'ideal': 45,
+        #             'max': 70,
+        #             'intensity': 'light_moderate',
+        #             'sessions': 'flexible',
+        #             'preferred_types': ['light_walks', 'moderate_activity']
+        #         },
+        #         'LOW': {
+        #             'min': 15,
+        #             'ideal': 30,
+        #             'max': 45,
+        #             'intensity': 'light',
+        #             'sessions': 'single',
+        #             'preferred_types': ['light_walks']
+        #         }
+        #     }
+            
+        #     # 獲取品種的運動需求配置
+        #     breed_level = exercise_levels.get(breed_needs.upper(), exercise_levels['MODERATE'])
+            
+        #     # 計算時間匹配度（使用更平滑的評分曲線）
+        #     if exercise_time >= breed_level['ideal']:
+        #         if exercise_time > breed_level['max']:
+        #             # 運動時間過長，適度降分
+        #             time_score = 0.15 - (0.05 * (exercise_time - breed_level['max']) / 30)
+        #         else:
+        #             time_score = 0.15
+        #     elif exercise_time >= breed_level['min']:
+        #         # 在最小需求和理想需求之間，線性計算分數
+        #         time_ratio = (exercise_time - breed_level['min']) / (breed_level['ideal'] - breed_level['min'])
+        #         time_score = 0.05 + (time_ratio * 0.10)
+        #     else:
+        #         # 運動時間不足，根據差距程度扣分
+        #         time_ratio = max(0, exercise_time / breed_level['min'])
+        #         time_score = -0.15 * (1 - time_ratio)
+            
+        #     # 運動類型匹配度評估
+        #     type_score = 0.0
+        #     if exercise_type in breed_level['preferred_types']:
+        #         type_score = 0.05
+        #         if exercise_type == breed_level['preferred_types'][0]:
+        #             type_score = 0.08  # 最佳匹配類型給予更高分數
+            
+        #     return max(-0.2, min(0.2, time_score + type_score))
+
+
+        def calculate_space_score(breed_info: dict, user_prefs: UserPreferences) -> float:
             """
-            優化的空間分數計算函數
+            計算品種與居住空間的匹配程度
             
-            主要改進：
-            1. 更均衡的基礎分數分配
-            2. 更細緻的空間需求評估
-            3. 強化運動需求與空間的關聯性
+            這個函數實現了一個全面的空間評分系統，考慮：
+            1. 基本空間需求（住所類型與品種大小的匹配）
+            2. 樓層因素（特別是公寓住戶）
+            3. 戶外活動空間（院子類型及可用性）
+            4. 室內活動空間的實際可用性
+            5. 品種的特殊空間需求
+            
+            Parameters:
+            -----------
+            breed_info: 包含品種特徵的字典，包括體型、活動需求等
+            user_prefs: 使用者偏好設定，包含居住條件相關信息
+            
+            Returns:
+            --------
+            float: 0.0-1.0 之間的匹配分數
             """
-            # 重新設計基礎分數矩陣，降低普遍分數以增加區別度
-            base_scores = {
+            # 取得品種基本信息
+            size = breed_info.get('Size', 'Medium')
+            temperament = breed_info.get('Temperament', '').lower()
+            exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+            
+            # 基礎空間需求評分矩陣 - 考慮品種大小與居住空間的基本匹配度
+            base_space_scores = {
                 "Small": {
-                    "apartment": 0.85,    # 降低滿分機會
-                    "house_small": 0.80,  # 小型犬不應在大空間得到太高分數
-                    "house_large": 0.75   # 避免小型犬總是得到最高分
+                    "apartment": 0.95,      # 小型犬最適合��寓
+                    "house_small": 0.90,    # 小房子也很適合
+                    "house_large": 0.85     # 大房子可能過大
                 },
                 "Medium": {
-                    "apartment": 0.45,    # 維持對公寓環境的限制
-                    "house_small": 0.75,  # 適中的分數
-                    "house_large": 0.85   # 給予合理的獎勵
+                    "apartment": 0.60,      # 中型犬在公寓有一定限制
+                    "house_small": 0.85,    # 小房子較適合
+                    "house_large": 0.95     # 大房子最理想
                 },
                 "Large": {
-                    "apartment": 0.15,    # 加重對大型犬在公寓的限制
-                    "house_small": 0.65,  # 中等適合度
-                    "house_large": 0.90   # 最適合的環境
+                    "apartment": 0.30,      # 大型犬不適合公寓
+                    "house_small": 0.70,    # 小房子稍嫌擁擠
+                    "house_large": 1.0      # 大房子最理想
                 },
                 "Giant": {
-                    "apartment": 0.10,    # 更嚴格的限制
-                    "house_small": 0.45,  # 顯著的空間限制
-                    "house_large": 0.95   # 最理想的配對
+                    "apartment": 0.20,      # 極大型犬極不適合公寓
+                    "house_small": 0.50,    # 小房子明顯不足
+                    "house_large": 1.0      # 大房子必需
                 }
             }
             
-            # 取得基礎分數
-            base_score = base_scores.get(size, base_scores["Medium"])[living_space]
-            
-            # 運動需求相關的調整更加動態
-            exercise_adjustments = {
-                "Very High": {
-                    "apartment": -0.25,    # 加重在受限空間的懲罰
-                    "house_small": -0.15,
-                    "house_large": -0.05
-                },
-                "High": {
-                    "apartment": -0.20,
-                    "house_small": -0.10,
-                    "house_large": 0
-                },
-                "Moderate": {
-                    "apartment": -0.10,
-                    "house_small": -0.05,
-                    "house_large": 0
-                },
-                "Low": {
-                    "apartment": 0.05,     # 低運動需求在小空間反而有優勢
-                    "house_small": 0,
-                    "house_large": -0.05   # 輕微降低評分，因為空間可能過大
-                }
+            # 取得基礎空間分數
+            base_score = base_space_scores.get(size, base_space_scores["Medium"])[user_prefs.living_space]
+            
+            # 公寓特殊考量
+            if user_prefs.living_space == "apartment":
+                # 樓層調整
+                floor_penalty = 0
+                if user_prefs.living_floor > 1:
+                    if size in ["Large", "Giant"]:
+                        floor_penalty = min(0.3, (user_prefs.living_floor - 1) * 0.05)
+                    elif size == "Medium":
+                        floor_penalty = min(0.2, (user_prefs.living_floor - 1) * 0.03)
+                    else:
+                        floor_penalty = min(0.1, (user_prefs.living_floor - 1) * 0.02)
+                base_score = max(0.2, base_score - floor_penalty)
+            
+            # 戶外空間評估
+            yard_scores = {
+                "no_yard": 0,
+                "shared_yard": 0.1,
+                "private_yard": 0.2
             }
             
-            # 根據空間類型獲取運動需求調整
-            adjustment = exercise_adjustments.get(exercise_needs, 
-                                                exercise_adjustments["Moderate"])[living_space]
-            
-            # 院子效益根據品種大小和運動需求動態調整
-            if has_yard:
-                yard_bonus = {
-                    "Giant": 0.20,
-                    "Large": 0.15,
-                    "Medium": 0.10,
-                    "Small": 0.05
-                }.get(size, 0.10)
-                
-                # 運動需求會影響院子的重要性
-                if exercise_needs in ["Very High", "High"]:
-                    yard_bonus *= 1.2
-                elif exercise_needs == "Low":
-                    yard_bonus *= 0.8
-                    
-                current_score = base_score + adjustment + yard_bonus
-            else:
-                current_score = base_score + adjustment
-                
-            # 確保分數在合理範圍內，但避免極端值
-            return min(0.95, max(0.15, current_score))
+            # 根據品種大小調整院子加分
+            yard_size_multipliers = {
+                "Giant": 1.2,
+                "Large": 1.1,
+                "Medium": 1.0,
+                "Small": 0.8
+            }
             
-
-        # def calculate_exercise_score(breed_needs: str, exercise_time: int) -> float:
-        #     """
-        #     優化的運動需求評分系統
+            yard_bonus = yard_scores[user_prefs.yard_access] * yard_size_multipliers.get(size, 1.0)
             
-        #     Parameters:
-        #     breed_needs: str - 品種的運動需求等級
-        #     exercise_time: int - 使用者可提供的運動時間（分鐘）
+            # 活動空間需求評估
+            activity_space_score = 0
+            if user_prefs.space_for_play:
+                if exercise_needs in ["VERY HIGH", "HIGH"]:
+                    activity_space_score = 0.15
+                elif exercise_needs == "MODERATE":
+                    activity_space_score = 0.10
+                else:
+                    activity_space_score = 0.05
             
-        #     改進：
-        #     1. 更細緻的運動需求評估
-        #     2. 更合理的時間匹配計算
-        #     3. 避免極端評分
-        #     """
-        #     # 基礎運動需求評估
-        #     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}
-        #     }
+            # 品種特性評估
+            temperament_adjustments = 0
+            if 'active' in temperament or 'energetic' in temperament:
+                if user_prefs.living_space == 'apartment':
+                    temperament_adjustments -= 0.15
+                elif user_prefs.living_space == 'house_small':
+                    temperament_adjustments -= 0.05
+                    
+            if 'calm' in temperament or 'lazy' in temperament:
+                if user_prefs.living_space == 'apartment':
+                    temperament_adjustments += 0.10
+                    
+            if 'adaptable' in temperament:
+                temperament_adjustments += 0.05
             
-        #     breed_need = exercise_needs.get(breed_needs.strip().upper(), exercise_needs['MODERATE'])
+            # 家庭環境考量
+            if user_prefs.has_children:
+                if user_prefs.living_space == 'apartment':
+                    # 公寓中有孩童需要更多活動空間
+                    if size in ["Large", "Giant"]:
+                        base_score *= 0.85
+                    elif size == "Medium":
+                        base_score *= 0.90
             
-        #     # 基礎時間匹配度計算
-        #     if exercise_time >= breed_need['ideal']:
-        #         if exercise_time > breed_need['max']:
-        #             # 運動時間過長，稍微降低分數
-        #             time_score = 0.9
-        #         else:
-        #             time_score = 1.0
-        #     elif exercise_time >= breed_need['min']:
-        #         # 在最小需求和理想需求之間，線性計算分數
-        #         time_score = 0.7 + (exercise_time - breed_need['min']) / (breed_need['ideal'] - breed_need['min']) * 0.3
-        #     else:
-        #         # 運動時間不足，但仍根據比例給予分數
-        #         time_score = max(0.3, 0.7 * (exercise_time / breed_need['min']))
+            # 整合所有評分因素
+            final_score = base_score + yard_bonus + activity_space_score + temperament_adjustments
             
-        #     # 確保分數在合理範圍內
-        #     return min(1.0, max(0.3, time_score))
+            # 確保最終分數在合理範圍內
+            return max(0.15, min(1.0, final_score))
 
 
-        def calculate_exercise_score(breed_needs: str, exercise_time: int, exercise_type: str) -> float:
+        def calculate_exercise_score(breed_needs: str, exercise_time: int, user_prefs: 'UserPreferences') -> float:
             """
-            精確評估品種運動需求與使用者運動條件的匹配度
+            計算品種運動需求與使用者條件的匹配分數
+            
+            這個函數實現了一個精細的運動評分系統，考慮：
+            1. 運動時間的匹配度（0-180分鐘）
+            2. 運動強度的適配性
+            3. 品種特性對運動的特殊需求
+            4. 生活方式的整體活躍度
             
             Parameters:
+            -----------
             breed_needs: 品種的運動需求等級
             exercise_time: 使用者能提供的運動時間（分鐘）
-            exercise_type: 使用者偏好的運動類型
+            user_prefs: 使用者偏好設定，包含運動類型和強度等信息
             
             Returns:
-            float: -0.2 到 0.2 之間的匹配分數
+            --------
+            float: 0.0-1.0 之間的匹配分數
             """
-            # 定義更細緻的運動需求等級
+            # 定義更精確的運動需求標準
             exercise_levels = {
                 'VERY HIGH': {
                     'min': 120,
                     'ideal': 150,
                     'max': 180,
-                    'intensity': 'high',
-                    'sessions': 'multiple',
-                    'preferred_types': ['active_training', 'intensive_exercise']
+                    'intensity_required': 'high',
+                    'intensity_factors': {'high': 1.2, 'moderate': 0.8, 'low': 0.6},
+                    'type_bonus': {'active_training': 0.15, 'moderate_activity': 0.05, 'light_walks': -0.1}
                 },
                 'HIGH': {
                     'min': 90,
                     'ideal': 120,
                     'max': 150,
-                    'intensity': 'moderate_high',
-                    'sessions': 'multiple',
-                    'preferred_types': ['active_training', 'moderate_activity']
+                    'intensity_required': 'moderate',
+                    'intensity_factors': {'high': 1.1, 'moderate': 1.0, 'low': 0.7},
+                    'type_bonus': {'active_training': 0.1, 'moderate_activity': 0.1, 'light_walks': -0.05}
                 },
-                'MODERATE HIGH': {
-                    'min': 70,
+                'MODERATE': {
+                    'min': 60,
                     'ideal': 90,
                     'max': 120,
-                    'intensity': 'moderate',
-                    'sessions': 'flexible',
-                    'preferred_types': ['moderate_activity', 'active_training']
+                    'intensity_required': 'moderate',
+                    'intensity_factors': {'high': 1.0, 'moderate': 1.0, 'low': 0.8},
+                    'type_bonus': {'active_training': 0.05, 'moderate_activity': 0.1, 'light_walks': 0.05}
                 },
-                'MODERATE': {
-                    'min': 45,
+                'LOW': {
+                    'min': 30,
                     'ideal': 60,
                     'max': 90,
-                    'intensity': 'moderate',
-                    'sessions': 'flexible',
-                    'preferred_types': ['moderate_activity', 'light_walks']
-                },
-                'MODERATE LOW': {
-                    'min': 30,
-                    'ideal': 45,
-                    'max': 70,
-                    'intensity': 'light_moderate',
-                    'sessions': 'flexible',
-                    'preferred_types': ['light_walks', 'moderate_activity']
-                },
-                'LOW': {
-                    'min': 15,
-                    'ideal': 30,
-                    'max': 45,
-                    'intensity': 'light',
-                    'sessions': 'single',
-                    'preferred_types': ['light_walks']
+                    'intensity_required': 'low',
+                    'intensity_factors': {'high': 0.7, 'moderate': 0.9, 'low': 1.0},
+                    'type_bonus': {'active_training': -0.05, 'moderate_activity': 0.05, 'light_walks': 0.1}
                 }
             }
             
-            # 獲取品種的運動需求配置
+            # 獲取品種運動需求配置
             breed_level = exercise_levels.get(breed_needs.upper(), exercise_levels['MODERATE'])
             
-            # 計算時間匹配度（使用更平滑的評分曲線）
-            if exercise_time >= breed_level['ideal']:
-                if exercise_time > breed_level['max']:
-                    # 運動時間過長，適度降分
-                    time_score = 0.15 - (0.05 * (exercise_time - breed_level['max']) / 30)
+            # 計算基礎運動時間分數
+            def calculate_time_score(time: int, level: dict) -> float:
+                if time < level['min']:
+                    # 運動時間不足，指數下降
+                    return max(0.3, (time / level['min']) ** 1.5)
+                elif time < level['ideal']:
+                    # 運動時間接近理想，線性增長
+                    return 0.7 + 0.3 * ((time - level['min']) / (level['ideal'] - level['min']))
+                elif time <= level['max']:
+                    # 理想運動時間範圍，高分保持
+                    return 1.0
                 else:
-                    time_score = 0.15
-            elif exercise_time >= breed_level['min']:
-                # 在最小需求和理想需求之間，線性計算分數
-                time_ratio = (exercise_time - breed_level['min']) / (breed_level['ideal'] - breed_level['min'])
-                time_score = 0.05 + (time_ratio * 0.10)
-            else:
-                # 運動時間不足，根據差距程度扣分
-                time_ratio = max(0, exercise_time / breed_level['min'])
-                time_score = -0.15 * (1 - time_ratio)
-            
-            # 運動類型匹配度評估
-            type_score = 0.0
-            if exercise_type in breed_level['preferred_types']:
-                type_score = 0.05
-                if exercise_type == breed_level['preferred_types'][0]:
-                    type_score = 0.08  # 最佳匹配類型給予更高分數
-            
-            return max(-0.2, min(0.2, time_score + type_score))
+                    # 運動時間過多，緩慢扣分
+                    excess = (time - level['max']) / 30  # 每超過30分鐘扣分
+                    return max(0.7, 1.0 - (excess * 0.1))
+            
+            # 計算運動時間基礎分數
+            time_score = calculate_time_score(exercise_time, breed_level)
+            
+            # 計算運動強度匹配度
+            intensity_factor = breed_level['intensity_factors'].get(user_prefs.exercise_intensity, 1.0)
+            
+            # 運動類型加成
+            type_bonus = breed_level['type_bonus'].get(user_prefs.exercise_type, 0)
+            
+            # 生活方式調整
+            lifestyle_adjustments = {
+                'sedentary': -0.1,
+                'moderate': 0,
+                'active': 0.1
+            }
+            lifestyle_factor = lifestyle_adjustments.get(user_prefs.lifestyle_activity, 0)
+            
+            # 整合所有因素
+            final_score = time_score * intensity_factor + type_bonus + lifestyle_factor
+            
+            # 確保分數在合理範圍內
+            return max(0.1, min(1.0, final_score))
 
 
         def calculate_grooming_score(breed_needs: str, user_commitment: str, breed_size: str) -> float:
@@ -1075,114 +987,275 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             return max(0.1, min(1.0, final_score))
 
 
-        def calculate_experience_score(care_level: str, user_experience: str, temperament: str) -> float:
+        # def calculate_experience_score(care_level: str, user_experience: str, temperament: str) -> float:
+        #     """
+        #     計算使用者經驗與品種需求的匹配分數，加強經驗等級的影響力
+            
+        #     重要改進：
+        #     1. 擴大基礎分數差異
+        #     2. 加重困難特徵的懲罰
+        #     3. 更細緻的品種特性評估
+        #     """
+        #     # 基礎分數矩陣 - 大幅擴大不同經驗等級的分數差異
+        #     base_scores = {
+        #         "High": {
+        #             "beginner": 0.10,      # 降低起始分，高難度品種對新手幾乎不推薦
+        #             "intermediate": 0.60,   # 中級玩家仍需謹慎
+        #             "advanced": 1.0        # 資深者能完全勝任
+        #         },
+        #         "Moderate": {
+        #             "beginner": 0.35,      # 適中難度對新手仍具挑戰
+        #             "intermediate": 0.80,   # 中級玩家較適合
+        #             "advanced": 1.0        # 資深者完全勝任
+        #         },
+        #         "Low": {
+        #             "beginner": 0.90,      # 新手友善品種
+        #             "intermediate": 0.95,   # 中級玩家幾乎完全勝任
+        #             "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.30,        # 固執性格嚴重影響新手
+        #             'independent': -0.25,      # 獨立性高的品種不適合新手
+        #             'dominant': -0.25,         # 支配性強的品種需要經驗處理
+        #             'strong-willed': -0.20,    # 強勢性格需要技巧管理
+        #             'protective': -0.20,       # 保護性強需要適當訓練
+        #             'aloof': -0.15,           # 冷漠性格需要耐心培養
+        #             'energetic': -0.15,       # 活潑好動需要經驗引導
+        #             'aggressive': -0.35        # 攻擊傾向極不適合新手
+        #         }
+                
+        #         # 新手友善的特徵 - 適度的獎勵
+        #         easy_traits = {
+        #             'gentle': 0.05,            # 溫和性格適合新手
+        #             'friendly': 0.05,          # 友善性格容易相處
+        #             'eager to please': 0.08,   # 願意服從較容易訓練
+        #             'patient': 0.05,           # 耐心的特質有助於建立關係
+        #             'adaptable': 0.05,         # 適應性強較容易照顧
+        #             'calm': 0.06              # 冷靜的性格較好掌握
+        #         }
+                
+        #         # 計算特徵調整
+        #         for trait, penalty in difficult_traits.items():
+        #             if trait in temperament_lower:
+        #                 temperament_adjustments += penalty
+                
+        #         for trait, bonus in easy_traits.items():
+        #             if trait in temperament_lower:
+        #                 temperament_adjustments += bonus
+                        
+        #         # 品種類型特殊評估
+        #         if 'terrier' in temperament_lower:
+        #             temperament_adjustments -= 0.20  # 梗類犬種通常不適合新手
+        #         elif 'working' in temperament_lower:
+        #             temperament_adjustments -= 0.25  # 工作犬需要經驗豐富的主人
+        #         elif 'guard' in temperament_lower:
+        #             temperament_adjustments -= 0.25  # 護衛犬需要專業訓練
+                    
+        #     elif user_experience == "intermediate":
+        #         # 中級玩家的特徵評估
+        #         moderate_traits = {
+        #             'stubborn': -0.15,        # 仍然需要注意，但懲罰較輕
+        #             'independent': -0.10,
+        #             'intelligent': 0.08,      # 聰明的特質可以好好發揮
+        #             'athletic': 0.06,         # 運動能力可以適當訓練
+        #             'versatile': 0.07,        # 多功能性可以開發
+        #             'protective': -0.08       # 保護性仍需注意
+        #         }
+                
+        #         for trait, adjustment in moderate_traits.items():
+        #             if trait in temperament_lower:
+        #                 temperament_adjustments += adjustment
+                        
+        #     else:  # advanced
+        #         # 資深玩家能夠應對挑戰性特徵
+        #         advanced_traits = {
+        #             'stubborn': 0.05,         # 困難特徵反而成為優勢
+        #             'independent': 0.05,
+        #             'intelligent': 0.10,
+        #             'protective': 0.05,
+        #             'strong-willed': 0.05
+        #         }
+                
+        #         for trait, bonus in advanced_traits.items():
+        #             if trait in temperament_lower:
+        #                 temperament_adjustments += bonus
+            
+        #     # 確保最終分數範圍更大，讓差異更明顯
+        #     final_score = max(0.05, min(1.0, score + temperament_adjustments))
+            
+        #     return final_score
+
+
+        def calculate_experience_score(breed_info: dict, user_prefs: UserPreferences) -> float:
             """
-            計算使用者經驗與品種需求的匹配分數，加強經驗等級的影響力
+            計算飼主經驗與品種需求的匹配分數
             
-            重要改進：
-            1. 擴大基礎分數差異
-            2. 加重困難特徵的懲罰
-            3. 更細緻的品種特性評估
+            這個函數實現了一個全面的經驗評分系統，考慮：
+            1. 品種的基本照護難度
+            2. 飼主的經驗水平
+            3. 特殊照護需求（如健康問題、行為訓練）
+            4. 時間投入與生活方式的匹配
+            5. 家庭環境對照護的影響
+            
+            特別注意：
+            - 新手飼主面對高難度品種時的顯著降分
+            - 資深飼主照顧簡單品種的微幅降分
+            - 特殊需求品種的額外評估
+            
+            Parameters:
+            -----------
+            breed_info: 包含品種特徵的字典
+            user_prefs: 使用者偏好設定
+            
+            Returns:
+            --------
+            float: 0.0-1.0 之間的匹配分數
             """
-            # 基礎分數矩陣 - 大幅擴大不同經驗等級的分數差異
-            base_scores = {
-                "High": {
-                    "beginner": 0.10,      # 降低起始分，高難度品種對新手幾乎不推薦
-                    "intermediate": 0.60,   # 中級玩家仍需謹慎
-                    "advanced": 1.0        # 資深者能完全勝任
+            care_level = breed_info.get('Care Level', 'MODERATE').upper()
+            temperament = breed_info.get('Temperament', '').lower()
+            health_issues = breed_info.get('Health Issues', '').lower()
+            
+            # 基礎照護難度評分矩陣
+            base_experience_scores = {
+                "HIGH": {
+                    "beginner": 0.30,      # 高難度品種對新手極具挑戰
+                    "intermediate": 0.70,   # 中級飼主需要額外努力
+                    "advanced": 0.95       # 資深飼主最適合
                 },
-                "Moderate": {
-                    "beginner": 0.35,      # 適中難度對新手仍具挑戰
-                    "intermediate": 0.80,   # 中級玩家較適合
-                    "advanced": 1.0        # 資深者完全勝任
+                "MODERATE": {
+                    "beginner": 0.60,      # 中等難度對新手有一定挑戰
+                    "intermediate": 0.85,   # 中級飼主較適合
+                    "advanced": 0.90       # 資深飼主可能稍嫌簡單
                 },
-                "Low": {
-                    "beginner": 0.90,      # 新手友善品種
-                    "intermediate": 0.95,   # 中級玩家幾乎完全勝任
-                    "advanced": 1.0        # 資深者完全勝任
+                "LOW": {
+                    "beginner": 0.90,      # 低難度適合新手
+                    "intermediate": 0.85,   # 中級飼主可能感覺無趣
+                    "advanced": 0.80       # 資深飼主可能缺乏挑戰
                 }
             }
             
-            # 取得基礎分數
-            score = base_scores.get(care_level, base_scores["Moderate"])[user_experience]
+            # 取得基礎經驗分數
+            base_score = base_experience_scores.get(care_level, 
+                                                  base_experience_scores["MODERATE"])[user_prefs.experience_level]
             
-            temperament_lower = temperament.lower()
-            temperament_adjustments = 0.0
+            # 時間可用性評估
+            time_adjustments = {
+                "limited": {
+                    "HIGH": -0.20,
+                    "MODERATE": -0.15,
+                    "LOW": -0.10
+                },
+                "moderate": {
+                    "HIGH": -0.10,
+                    "MODERATE": -0.05,
+                    "LOW": 0
+                },
+                "flexible": {
+                    "HIGH": 0,
+                    "MODERATE": 0.05,
+                    "LOW": 0.10
+                }
+            }
             
-            # 根據經驗等級設定不同的特徵評估標準
-            if user_experience == "beginner":
-                # 新手不適合的特徵 - 更嚴格的懲罰
+            time_adjustment = time_adjustments[user_prefs.time_availability][care_level]
+            
+            # 行為特徵評估
+            def evaluate_temperament(temp: str, exp_level: str) -> float:
+                """評估品種性格特徵與飼主經驗的匹配度"""
+                score = 0
+                
+                # 困難特徵評估
                 difficult_traits = {
-                    'stubborn': -0.30,        # 固執性格嚴重影響新手
-                    'independent': -0.25,      # 獨立性高的品種不適合新手
-                    'dominant': -0.25,         # 支配性強的品種需要經驗處理
-                    'strong-willed': -0.20,    # 強勢性格需要技巧管理
-                    'protective': -0.20,       # 保護性強需要適當訓練
-                    'aloof': -0.15,           # 冷漠性格需要耐心培養
-                    'energetic': -0.15,       # 活潑好動需要經驗引導
-                    'aggressive': -0.35        # 攻擊傾向極不適合新手
+                    'stubborn': {'beginner': -0.20, 'intermediate': -0.10, 'advanced': 0},
+                    'independent': {'beginner': -0.15, 'intermediate': -0.08, 'advanced': 0},
+                    'dominant': {'beginner': -0.20, 'intermediate': -0.10, 'advanced': -0.05},
+                    'aggressive': {'beginner': -0.25, 'intermediate': -0.15, 'advanced': -0.10}
                 }
                 
-                # 新手友善的特徵 - 適度的獎勵
-                easy_traits = {
-                    'gentle': 0.05,            # 溫和性格適合新手
-                    'friendly': 0.05,          # 友善性格容易相處
-                    'eager to please': 0.08,   # 願意服從較容易訓練
-                    'patient': 0.05,           # 耐心的特質有助於建立關係
-                    'adaptable': 0.05,         # 適應性強較容易照顧
-                    'calm': 0.06              # 冷靜的性格較好掌握
+                # 友善特徵評估
+                friendly_traits = {
+                    'friendly': {'beginner': 0.10, 'intermediate': 0.05, 'advanced': 0},
+                    'gentle': {'beginner': 0.10, 'intermediate': 0.05, 'advanced': 0},
+                    'easy to train': {'beginner': 0.15, 'intermediate': 0.10, 'advanced': 0.05}
                 }
                 
-                # 計算特徵調整
-                for trait, penalty in difficult_traits.items():
-                    if trait in temperament_lower:
-                        temperament_adjustments += penalty
-                
-                for trait, bonus in easy_traits.items():
-                    if trait in temperament_lower:
-                        temperament_adjustments += bonus
+                # 計算特徵分數
+                for trait, penalties in difficult_traits.items():
+                    if trait in temp:
+                        score += penalties[exp_level]
                         
-                # 品種類型特殊評估
-                if 'terrier' in temperament_lower:
-                    temperament_adjustments -= 0.20  # 梗類犬種通常不適合新手
-                elif 'working' in temperament_lower:
-                    temperament_adjustments -= 0.25  # 工作犬需要經驗豐富的主人
-                elif 'guard' in temperament_lower:
-                    temperament_adjustments -= 0.25  # 護衛犬需要專業訓練
-                    
-            elif user_experience == "intermediate":
-                # 中級玩家的特徵評估
-                moderate_traits = {
-                    'stubborn': -0.15,        # 仍然需要注意，但懲罰較輕
-                    'independent': -0.10,
-                    'intelligent': 0.08,      # 聰明的特質可以好好發揮
-                    'athletic': 0.06,         # 運動能力可以適當訓練
-                    'versatile': 0.07,        # 多功能性可以開發
-                    'protective': -0.08       # 保護性仍需注意
+                for trait, bonuses in friendly_traits.items():
+                    if trait in temp:
+                        score += bonuses[exp_level]
+                
+                return score
+            
+            temperament_adjustment = evaluate_temperament(temperament, user_prefs.experience_level)
+            
+            # 健康問題評估
+            def evaluate_health_needs(health: str, exp_level: str) -> float:
+                """評估健康問題的照護難度"""
+                score = 0
+                serious_conditions = ['hip dysplasia', 'heart disease', 'cancer']
+                moderate_conditions = ['allergies', 'skin problems', 'ear infections']
+                
+                # 根據經驗等級調整健康問題的影響
+                health_impact = {
+                    'beginner': {'serious': -0.20, 'moderate': -0.10},
+                    'intermediate': {'serious': -0.15, 'moderate': -0.05},
+                    'advanced': {'serious': -0.10, 'moderate': -0.03}
                 }
                 
-                for trait, adjustment in moderate_traits.items():
-                    if trait in temperament_lower:
-                        temperament_adjustments += adjustment
+                for condition in serious_conditions:
+                    if condition in health:
+                        score += health_impact[exp_level]['serious']
                         
-            else:  # advanced
-                # 資深玩家能夠應對挑戰性特徵
-                advanced_traits = {
-                    'stubborn': 0.05,         # 困難特徵反而成為優勢
-                    'independent': 0.05,
-                    'intelligent': 0.10,
-                    'protective': 0.05,
-                    'strong-willed': 0.05
-                }
+                for condition in moderate_conditions:
+                    if condition in health:
+                        score += health_impact[exp_level]['moderate']
                 
-                for trait, bonus in advanced_traits.items():
-                    if trait in temperament_lower:
-                        temperament_adjustments += bonus
+                return score
             
-            # 確保最終分數範圍更大，讓差異更明顯
-            final_score = max(0.05, min(1.0, score + temperament_adjustments))
+            health_adjustment = evaluate_health_needs(health_issues, user_prefs.experience_level)
             
-            return final_score
+            # 家庭環境考量
+            family_adjustment = 0
+            if user_prefs.has_children:
+                if user_prefs.children_age == 'toddler':
+                    if user_prefs.experience_level == 'beginner':
+                        family_adjustment -= 0.15
+                    elif user_prefs.experience_level == 'intermediate':
+                        family_adjustment -= 0.10
+                elif user_prefs.children_age == 'school_age':
+                    if user_prefs.experience_level == 'beginner':
+                        family_adjustment -= 0.10
+            
+            # 生活方式匹配度
+            lifestyle_adjustments = {
+                'sedentary': -0.10 if care_level == 'HIGH' else 0,
+                'moderate': 0,
+                'active': 0.10 if care_level in ['HIGH', 'MODERATE'] else 0
+            }
+            lifestyle_adjustment = lifestyle_adjustments[user_prefs.lifestyle_activity]
+            
+            # 整合所有評分因素
+            final_score = base_score + time_adjustment + temperament_adjustment + \
+                         health_adjustment + family_adjustment + lifestyle_adjustment
+            
+            # 確保最終分數在合理範圍內
+            return max(0.15, min(1.0, final_score))
+    
 
         def calculate_health_score(breed_name: str, user_prefs: UserPreferences) -> float:
             """
@@ -1292,128 +1365,311 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             return max(0.1, min(1.0, health_score))
             
 
-        def calculate_noise_score(breed_name: str, user_prefs: UserPreferences) -> float:
-            """
-            計算品種噪音分數，特別加強噪音程度與生活環境的關聯性評估
-            """
-            if breed_name not in breed_noise_info:
-                return 0.5
+        # def calculate_noise_score(breed_name: str, user_prefs: UserPreferences) -> 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()
+        #     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.95,   # 安靜的狗對一般容忍很好
-                    'high': 0.90      # 安靜的狗對高容忍當然可以
-                },
-                'medium': {
-                    'low': 0.60,      # 一般吠叫對低容忍較困難
-                    'medium': 0.90,   # 一般吠叫對一般容忍可接受
-                    'high': 0.95      # 一般吠叫對高容忍很好
-                },
-                'high': {
-                    'low': 0.25,      # 愛叫的狗對低容忍極不適合
-                    'medium': 0.65,   # 愛叫的狗對一般容忍有挑戰
-                    'high': 0.90      # 愛叫的狗對高容忍可以接受
-                },
-                'varies': {
-                    'low': 0.50,      # 不確定的情況對低容忍風險較大
-                    'medium': 0.75,   # 不確定的情況對一般容忍可嘗試
-                    'high': 0.85      # 不確定的情況對高容忍問題較小
-                }
-            }
+        #     # 重新設計基礎噪音分數矩陣，考慮不同情境下的接受度
+        #     base_scores = {
+        #         'low': {
+        #             'low': 1.0,       # 安靜的狗對低容忍完美匹配
+        #             'medium': 0.95,   # 安靜的狗對一般容忍很好
+        #             'high': 0.90      # 安靜的狗對高容忍當然可以
+        #         },
+        #         'medium': {
+        #             'low': 0.60,      # 一般吠叫對低容忍較困難
+        #             'medium': 0.90,   # 一般吠叫對一般容忍可接受
+        #             'high': 0.95      # 一般吠叫對高容忍很好
+        #         },
+        #         'high': {
+        #             'low': 0.25,      # 愛叫的狗對低容忍極不適合
+        #             'medium': 0.65,   # 愛叫的狗對一般容忍有挑戰
+        #             'high': 0.90      # 愛叫的狗對高容忍可以接受
+        #         },
+        #         'varies': {
+        #             'low': 0.50,      # 不確定的情況對低容忍風險較大
+        #             'medium': 0.75,   # 不確定的情況對一般容忍可嘗試
+        #             'high': 0.85      # 不確定的情況對高容忍問題較小
+        #         }
+        #     }
         
-            # 取得基礎分數
-            base_score = base_scores.get(noise_level, {'low': 0.6, 'medium': 0.75, 'high': 0.85})[user_prefs.noise_tolerance]
+        #     # 取得基礎分數
+        #     base_score = base_scores.get(noise_level, {'low': 0.6, 'medium': 0.75, 'high': 0.85})[user_prefs.noise_tolerance]
         
-            # 吠叫原因評估，根據環境調整懲罰程度
-            barking_penalties = {
-                'separation anxiety': {
-                    'apartment': -0.30,    # 在公寓對鄰居影響更大
-                    'house_small': -0.25,
-                    'house_large': -0.20
-                },
-                'excessive barking': {
-                    'apartment': -0.25,
-                    'house_small': -0.20,
-                    'house_large': -0.15
-                },
-                'territorial': {
-                    'apartment': -0.20,    # 在公寓更容易被觸發
-                    'house_small': -0.15,
-                    'house_large': -0.10
+        #     # 吠叫原因評估，根據環境調整懲罰程度
+        #     barking_penalties = {
+        #         'separation anxiety': {
+        #             'apartment': -0.30,    # 在公寓對鄰居影響更大
+        #             'house_small': -0.25,
+        #             'house_large': -0.20
+        #         },
+        #         'excessive barking': {
+        #             'apartment': -0.25,
+        #             'house_small': -0.20,
+        #             'house_large': -0.15
+        #         },
+        #         'territorial': {
+        #             'apartment': -0.20,    # 在公寓更容易被觸發
+        #             'house_small': -0.15,
+        #             'house_large': -0.10
+        #         },
+        #         'alert barking': {
+        #             'apartment': -0.15,    # 公寓環境刺激較多
+        #             'house_small': -0.10,
+        #             'house_large': -0.08
+        #         },
+        #         'attention seeking': {
+        #             'apartment': -0.15,
+        #             'house_small': -0.12,
+        #             'house_large': -0.10
+        #         }
+        #     }
+        
+        #     # 計算環境相關的吠叫懲罰
+        #     living_space = user_prefs.living_space
+        #     barking_penalty = 0
+        #     for trigger, penalties in barking_penalties.items():
+        #         if trigger in noise_notes:
+        #             barking_penalty += penalties.get(living_space, -0.15)
+        
+        #     # 特殊情況評估
+        #     special_adjustments = 0
+        #     if user_prefs.has_children:
+        #         # 孩童年齡相關調整
+        #         child_age_adjustments = {
+        #             'toddler': {
+        #                 'high': -0.20,     # 幼童對吵鬧更敏感
+        #                 'medium': -0.15,
+        #                 'low': -0.05
+        #             },
+        #             'school_age': {
+        #                 'high': -0.15,
+        #                 'medium': -0.10,
+        #                 'low': -0.05
+        #             },
+        #             'teenager': {
+        #                 'high': -0.10,
+        #                 'medium': -0.05,
+        #                 'low': -0.02
+        #             }
+        #         }
+                
+        #         # 根據孩童年齡和噪音等級調整
+        #         age_adj = child_age_adjustments.get(user_prefs.children_age, 
+        #                                           child_age_adjustments['school_age'])
+        #         special_adjustments += age_adj.get(noise_level, -0.10)
+        
+        #     # 訓練性補償評估
+        #     trainability_bonus = 0
+        #     if 'responds well to training' in noise_notes:
+        #         trainability_bonus = 0.12
+        #     elif 'can be trained' in noise_notes:
+        #         trainability_bonus = 0.08
+        #     elif 'difficult to train' in noise_notes:
+        #         trainability_bonus = 0.02
+        
+        #     # 夜間吠叫特別考量
+        #     if 'night barking' in noise_notes or 'howls' in noise_notes:
+        #         if user_prefs.living_space == 'apartment':
+        #             special_adjustments -= 0.15
+        #         elif user_prefs.living_space == 'house_small':
+        #             special_adjustments -= 0.10
+        #         else:
+        #             special_adjustments -= 0.05
+        
+        #     # 計算最終分數，確保更大的分數範圍
+        #     final_score = base_score + barking_penalty + special_adjustments + trainability_bonus
+        #     return max(0.1, min(1.0, final_score))
+
+
+        def calculate_noise_score(breed_info: dict, user_prefs: UserPreferences) -> float:
+            """
+            計算品種噪音特性與使用者需求的匹配分數
+            
+            這個函數建立了一個細緻的噪音評估系統，考慮多個關鍵因素：
+            1. 品種的基本吠叫傾向
+            2. 居住環境對噪音的敏感度
+            3. 吠叫的情境和原因
+            4. 鄰居影響的考量
+            5. 家庭成員的噪音承受度
+            6. 訓練可能性的評估
+            
+            特別注意：
+            - 公寓環境的嚴格標準
+            - 有幼童時的特殊考量
+            - 獨處時間的影響
+            - 品種的可訓練性
+            
+            Parameters:
+            -----------
+            breed_info: 包含品種特性的字典，包括吠叫傾向和訓練難度
+            user_prefs: 使用者偏好設定，包含噪音容忍度和環境因素
+            
+            Returns:
+            --------
+            float: 0.0-1.0 之間的匹配分數，分數越高表示噪音特性越符合需求
+            """
+            
+            # 提取基本資訊
+            noise_level = breed_info.get('Noise Level', 'MODERATE').upper()
+            barking_tendency = breed_info.get('Barking Tendency', 'MODERATE').upper()
+            trainability = breed_info.get('Trainability', 'MODERATE').upper()
+            temperament = breed_info.get('Temperament', '').lower()
+            
+            # 基礎噪音評分矩陣 - 考慮環境和噪音容忍度
+            base_noise_scores = {
+                "LOW": {
+                    "apartment": {
+                        "low": 1.0,     # 安靜的狗在公寓最理想
+                        "medium": 0.95,
+                        "high": 0.90
+                    },
+                    "house_small": {
+                        "low": 0.95,
+                        "medium": 0.90,
+                        "high": 0.85
+                    },
+                    "house_large": {
+                        "low": 0.90,
+                        "medium": 0.85,
+                        "high": 0.80    # 太安靜可能不夠警戒
+                    }
                 },
-                'alert barking': {
-                    'apartment': -0.15,    # 公寓環境刺激較多
-                    'house_small': -0.10,
-                    'house_large': -0.08
+                "MODERATE": {
+                    "apartment": {
+                        "low": 0.60,
+                        "medium": 0.80,
+                        "high": 0.85
+                    },
+                    "house_small": {
+                        "low": 0.70,
+                        "medium": 0.85,
+                        "high": 0.90
+                    },
+                    "house_large": {
+                        "low": 0.75,
+                        "medium": 0.90,
+                        "high": 0.95
+                    }
                 },
-                'attention seeking': {
-                    'apartment': -0.15,
-                    'house_small': -0.12,
-                    'house_large': -0.10
+                "HIGH": {
+                    "apartment": {
+                        "low": 0.20,    # 吵鬧的狗在公寓極不適合
+                        "medium": 0.40,
+                        "high": 0.60
+                    },
+                    "house_small": {
+                        "low": 0.30,
+                        "medium": 0.50,
+                        "high": 0.70
+                    },
+                    "house_large": {
+                        "low": 0.40,
+                        "medium": 0.60,
+                        "high": 0.80
+                    }
                 }
             }
-        
-            # 計算環境相關的吠叫懲罰
-            living_space = user_prefs.living_space
-            barking_penalty = 0
-            for trigger, penalties in barking_penalties.items():
-                if trigger in noise_notes:
-                    barking_penalty += penalties.get(living_space, -0.15)
-        
-            # 特殊情況評估
-            special_adjustments = 0
-            if user_prefs.has_children:
-                # 孩童年齡相關調整
-                child_age_adjustments = {
-                    'toddler': {
-                        'high': -0.20,     # 幼童對吵鬧更敏感
-                        'medium': -0.15,
-                        'low': -0.05
+            
+            # 取得基礎噪音分數
+            base_score = base_noise_scores.get(noise_level, base_noise_scores["MODERATE"])\
+                        [user_prefs.living_space][user_prefs.noise_tolerance]
+            
+            # 吠叫情境評估
+            def evaluate_barking_context(temp: str, living_space: str) -> float:
+                """評估不同情境下的吠叫問題嚴重度"""
+                context_score = 0
+                
+                # 不同吠叫原因的權重
+                barking_contexts = {
+                    'separation anxiety': {
+                        'apartment': -0.25,
+                        'house_small': -0.20,
+                        'house_large': -0.15
                     },
-                    'school_age': {
-                        'high': -0.15,
-                        'medium': -0.10,
-                        'low': -0.05
+                    'territorial': {
+                        'apartment': -0.20,
+                        'house_small': -0.15,
+                        'house_large': -0.10
+                    },
+                    'alert barking': {
+                        'apartment': -0.15,
+                        'house_small': -0.10,
+                        'house_large': -0.05
                     },
-                    'teenager': {
-                        'high': -0.10,
-                        'medium': -0.05,
-                        'low': -0.02
+                    'attention seeking': {
+                        'apartment': -0.15,
+                        'house_small': -0.10,
+                        'house_large': -0.08
                     }
                 }
                 
-                # 根據孩童年齡和噪音等級調整
-                age_adj = child_age_adjustments.get(user_prefs.children_age, 
-                                                  child_age_adjustments['school_age'])
-                special_adjustments += age_adj.get(noise_level, -0.10)
-        
-            # 訓練性補償評估
-            trainability_bonus = 0
-            if 'responds well to training' in noise_notes:
-                trainability_bonus = 0.12
-            elif 'can be trained' in noise_notes:
-                trainability_bonus = 0.08
-            elif 'difficult to train' in noise_notes:
-                trainability_bonus = 0.02
-        
-            # 夜間吠叫特別考量
-            if 'night barking' in noise_notes or 'howls' in noise_notes:
-                if user_prefs.living_space == 'apartment':
-                    special_adjustments -= 0.15
-                elif user_prefs.living_space == 'house_small':
-                    special_adjustments -= 0.10
-                else:
-                    special_adjustments -= 0.05
-        
-            # 計算最終分數，確保更大的分數範圍
-            final_score = base_score + barking_penalty + special_adjustments + trainability_bonus
-            return max(0.1, min(1.0, final_score))
+                for context, penalties in barking_contexts.items():
+                    if context in temp:
+                        context_score += penalties[living_space]
+                
+                return context_score
+            
+            # 計算吠叫情境的影響
+            barking_context_adjustment = evaluate_barking_context(temperament, user_prefs.living_space)
+            
+            # 訓練可能性評估
+            trainability_adjustments = {
+                "HIGH": 0.10,      # 容易訓練可以改善吠叫問題
+                "MODERATE": 0.05,
+                "LOW": -0.05      # 難以訓練則較難改善
+            }
+            trainability_adjustment = trainability_adjustments.get(trainability, 0)
+            
+            # 家庭環境考量
+            family_adjustment = 0
+            if user_prefs.has_children:
+                child_age_factors = {
+                    'toddler': -0.20,    # 幼童需要安靜環境
+                    'school_age': -0.15,
+                    'teenager': -0.10
+                }
+                family_adjustment = child_age_factors.get(user_prefs.children_age, -0.15)
+                
+                # 根據噪音等級調整影響程度
+                if noise_level == "HIGH":
+                    family_adjustment *= 1.5
+                elif noise_level == "LOW":
+                    family_adjustment *= 0.5
+            
+            # 獨處時間的影響
+            alone_time_adjustment = 0
+            if user_prefs.home_alone_time > 6:
+                if 'separation anxiety' in temperament or noise_level == "HIGH":
+                    alone_time_adjustment = -0.15
+                elif noise_level == "MODERATE":
+                    alone_time_adjustment = -0.10
+            
+            # 鄰居影響評估（特別是公寓環境）
+            neighbor_adjustment = 0
+            if user_prefs.living_space == "apartment":
+                if noise_level == "HIGH":
+                    neighbor_adjustment = -0.15
+                elif noise_level == "MODERATE":
+                    neighbor_adjustment = -0.10
+                    
+                # 樓層因素
+                if user_prefs.living_floor > 1:
+                    neighbor_adjustment -= min(0.10, (user_prefs.living_floor - 1) * 0.02)
+            
+            # 整合所有評分因素
+            final_score = base_score + barking_context_adjustment + trainability_adjustment + \
+                         family_adjustment + alone_time_adjustment + neighbor_adjustment
+            
+            # 確保最終分數在合理範圍內
+            return max(0.15, min(1.0, final_score))
             
 
         # 1. 計算基礎分數
@@ -1508,126 +1764,328 @@ def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -
     return min(0.2, adaptability_score)
 
 
-def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
-    """
-    改進的品種相容性評分系統
-    通過更細緻的特徵評估和動態權重調整，自然產生分數差異
-    """
-    # 評估關鍵特徵的匹配度，使用更極端的調整係數
-    def evaluate_key_features():
-        # 空間適配性評估
-        space_multiplier = 1.0
-        if user_prefs.living_space == 'apartment':
-            if breed_info['Size'] == 'Giant':
-                space_multiplier = 0.3  # 嚴重不適合
-            elif breed_info['Size'] == 'Large':
-                space_multiplier = 0.4  # 明顯不適合
-            elif breed_info['Size'] == 'Small':
-                space_multiplier = 1.4  # 明顯優勢
+# def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
+#     """
+#     改進的品種相容性評分系統
+#     通過更細緻的特徵評估和動態權重調整，自然產生分數差異
+#     """
+#     # 評估關鍵特徵的匹配度，使用更極端的調整係數
+#     def evaluate_key_features():
+#         # 空間適配性評估
+#         space_multiplier = 1.0
+#         if user_prefs.living_space == 'apartment':
+#             if breed_info['Size'] == 'Giant':
+#                 space_multiplier = 0.3  # 嚴重不適合
+#             elif breed_info['Size'] == 'Large':
+#                 space_multiplier = 0.4  # 明顯不適合
+#             elif breed_info['Size'] == 'Small':
+#                 space_multiplier = 1.4  # 明顯優勢
         
-        # 運動需求評估
-        exercise_multiplier = 1.0
-        exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
-        if exercise_needs == 'VERY HIGH':
-            if user_prefs.exercise_time < 60:
-                exercise_multiplier = 0.3  # 嚴重不足
-            elif user_prefs.exercise_time > 150:
-                exercise_multiplier = 1.5  # 完美匹配
-        elif exercise_needs == 'LOW' and user_prefs.exercise_time > 150:
-            exercise_multiplier = 0.5  # 運動過度
+#         # 運動需求評估
+#         exercise_multiplier = 1.0
+#         exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+#         if exercise_needs == 'VERY HIGH':
+#             if user_prefs.exercise_time < 60:
+#                 exercise_multiplier = 0.3  # 嚴重不足
+#             elif user_prefs.exercise_time > 150:
+#                 exercise_multiplier = 1.5  # 完美匹配
+#         elif exercise_needs == 'LOW' and user_prefs.exercise_time > 150:
+#             exercise_multiplier = 0.5  # 運動過度
 
-        return space_multiplier, exercise_multiplier
+#         return space_multiplier, exercise_multiplier
 
-    # 計算經驗匹配度
-    def evaluate_experience():
-        exp_multiplier = 1.0
-        care_level = breed_info.get('Care Level', 'MODERATE')
+#     # 計算經驗匹配度
+#     def evaluate_experience():
+#         exp_multiplier = 1.0
+#         care_level = breed_info.get('Care Level', 'MODERATE')
         
-        if care_level == 'High':
-            if user_prefs.experience_level == 'beginner':
-                exp_multiplier = 0.4
-            elif user_prefs.experience_level == 'advanced':
-                exp_multiplier = 1.3
-        elif care_level == 'Low':
-            if user_prefs.experience_level == 'advanced':
-                exp_multiplier = 0.9  # 略微降低評分，因為可能不夠有挑戰性
+#         if care_level == 'High':
+#             if user_prefs.experience_level == 'beginner':
+#                 exp_multiplier = 0.4
+#             elif user_prefs.experience_level == 'advanced':
+#                 exp_multiplier = 1.3
+#         elif care_level == 'Low':
+#             if user_prefs.experience_level == 'advanced':
+#                 exp_multiplier = 0.9  # 略微降低評分，因為可能不夠有挑戰性
                 
-        return exp_multiplier
+#         return exp_multiplier
 
-    # 取得特徵調整係數
-    space_mult, exercise_mult = evaluate_key_features()
-    exp_mult = evaluate_experience()
+#     # 取得特徵調整係數
+#     space_mult, exercise_mult = evaluate_key_features()
+#     exp_mult = evaluate_experience()
 
-    # 調整基礎分數
-    adjusted_scores = {
-        'space': scores['space'] * space_mult,
-        'exercise': scores['exercise'] * exercise_mult,
-        'experience': scores['experience'] * exp_mult,
-        'grooming': scores['grooming'],
-        'health': scores['health'],
-        'noise': scores['noise']
-    }
+#     # 調整基礎分數
+#     adjusted_scores = {
+#         'space': scores['space'] * space_mult,
+#         'exercise': scores['exercise'] * exercise_mult,
+#         'experience': scores['experience'] * exp_mult,
+#         'grooming': scores['grooming'],
+#         'health': scores['health'],
+#         'noise': scores['noise']
+#     }
 
-    # 計算加權平均，關鍵特徵佔更大權重
-    weights = {
-        'space': 0.35,
-        'exercise': 0.30,
-        'experience': 0.20,
-        'grooming': 0.15,
-        'health': 0.10,
-        'noise': 0.10
-    }
+#     # 計算加權平均，關鍵特徵佔更大權重
+#     weights = {
+#         'space': 0.35,
+#         'exercise': 0.30,
+#         'experience': 0.20,
+#         'grooming': 0.15,
+#         'health': 0.10,
+#         'noise': 0.10
+#     }
 
-    # 動態調整權重
-    if user_prefs.living_space == 'apartment':
-        weights['space'] *= 1.5
-        weights['noise'] *= 1.3
+#     # 動態調整權重
+#     if user_prefs.living_space == 'apartment':
+#         weights['space'] *= 1.5
+#         weights['noise'] *= 1.3
     
-    if abs(user_prefs.exercise_time - 120) > 60:  # 運動時間極端情況
-        weights['exercise'] *= 1.4
+#     if abs(user_prefs.exercise_time - 120) > 60:  # 運動時間極端情況
+#         weights['exercise'] *= 1.4
+
+#     # 正規化權重
+#     total_weight = sum(weights.values())
+#     normalized_weights = {k: v/total_weight for k, v in weights.items()}
 
-    # 正規化權重
-    total_weight = sum(weights.values())
-    normalized_weights = {k: v/total_weight for k, v in weights.items()}
+#     # 計算最終分數
+#     final_score = sum(adjusted_scores[k] * normalized_weights[k] for k in scores.keys())
+
+#     # 品種特性加成
+#     breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
+    
+#     # 整合最終分數，保持在0-1範圍內
+#     return min(1.0, max(0.0, (final_score * 0.85) + (breed_bonus * 0.15)))
 
-    # 計算最終分數
-    final_score = sum(adjusted_scores[k] * normalized_weights[k] for k in scores.keys())
 
-    # 品種特性加成
-    breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
+def calculate_compatibility_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
+    """
+    計算品種與使用者的整體相容性分數
+    
+    這是推薦系統的核心評分函數，負責：
+    1. 智能整合各面向評分
+    2. 動態調整評分權重
+    3. 處理關鍵條件的優先級
+    4. 產生最終的匹配分數
+    
+    評分策略：
+    - 基礎分數：由各項指標的加權平均獲得
+    - 動態權重：根據用戶情況動態調整各項權重
+    - 關鍵條件：某些條件不滿足會顯著降低總分
+    - 加成系統：特殊匹配會提供額外加分
+    
+    Parameters:
+    -----------
+    scores: 包含各項評分的字典
+    user_prefs: 使用者偏好設定
+    breed_info: 品種特性信息
+    
+    Returns:
+    --------
+    float: 60.0-95.0 之間的最終匹配分數
+    """
+    def calculate_dynamic_weights() -> dict:
+        """計算動態權重分配"""
+        # 基礎權重設定
+        weights = {
+            'space': 0.20,
+            'exercise': 0.20,
+            'experience': 0.15,
+            'grooming': 0.15,
+            'health': 0.15,
+            'noise': 0.15
+        }
+        
+        # 公寓住戶權重調整
+        if user_prefs.living_space == "apartment":
+            weights['space'] *= 1.3
+            weights['noise'] *= 1.3
+            weights['exercise'] *= 0.8
+        
+        # 有幼童時的權重調整
+        if user_prefs.has_children and user_prefs.children_age == 'toddler':
+            weights['experience'] *= 1.3
+            weights['noise'] *= 1.2
+            weights['health'] *= 1.2
+        
+        # 新手飼主的權重調整
+        if user_prefs.experience_level == 'beginner':
+            weights['experience'] *= 1.4
+            weights['health'] *= 1.2
+            weights['grooming'] *= 1.2
+        
+        # 健康敏感度的權重調整
+        if user_prefs.health_sensitivity == 'high':
+            weights['health'] *= 1.3
+        
+        # 運動時間極端情況的權重調整
+        if abs(user_prefs.exercise_time - 120) > 60:
+            weights['exercise'] *= 1.3
+        
+        # 正規化權重
+        total = sum(weights.values())
+        return {k: v/total for k, v in weights.items()}
     
-    # 整合最終分數，保持在0-1範圍內
-    return min(1.0, max(0.0, (final_score * 0.85) + (breed_bonus * 0.15)))
+    def calculate_critical_factors() -> float:
+        """評估關鍵因素的影響"""
+        critical_score = 1.0
+        
+        # 空間關鍵條件
+        if user_prefs.living_space == "apartment":
+            if breed_info['Size'] == 'Giant':
+                critical_score *= 0.7
+            elif breed_info['Size'] == 'Large':
+                critical_score *= 0.8
+        
+        # 運動需求關鍵條件
+        exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+        if exercise_needs == 'VERY HIGH' and user_prefs.exercise_time < 60:
+            critical_score *= 0.75
+        elif exercise_needs == 'HIGH' and user_prefs.exercise_time < 45:
+            critical_score *= 0.8
+        
+        # 新手飼主關鍵條件
+        if user_prefs.experience_level == 'beginner':
+            if 'aggressive' in breed_info.get('Temperament', '').lower():
+                critical_score *= 0.7
+            elif 'dominant' in breed_info.get('Temperament', '').lower():
+                critical_score *= 0.8
+        
+        # 噪音關鍵條件
+        if user_prefs.living_space == "apartment" and \
+           breed_info.get('Noise Level', 'MODERATE').upper() == 'HIGH' and \
+           user_prefs.noise_tolerance == 'low':
+            critical_score *= 0.7
+        
+        return critical_score
     
+    def calculate_bonus_factors() -> float:
+        """計算額外加分因素"""
+        bonus = 1.0
+        temperament = breed_info.get('Temperament', '').lower()
+        
+        # 完美匹配加分
+        perfect_matches = 0
+        for score in scores.values():
+            if score > 0.9:
+                perfect_matches += 1
+        
+        if perfect_matches >= 3:
+            bonus += 0.05
+        
+        # 特殊匹配加分
+        if user_prefs.has_children and 'good with children' in temperament:
+            bonus += 0.03
+        
+        if user_prefs.living_space == "apartment" and 'adaptable' in temperament:
+            bonus += 0.03
+        
+        if user_prefs.experience_level == 'beginner' and 'easy to train' in temperament:
+            bonus += 0.03
+        
+        return min(1.15, bonus)
+    
+    # 計算動態權重
+    weights = calculate_dynamic_weights()
+    
+    # 計算基礎加權分數
+    base_score = sum(scores[k] * weights[k] for k in scores.keys())
+    
+    # 應用關鍵因素
+    critical_factor = calculate_critical_factors()
+    
+    # 計算加分
+    bonus_factor = calculate_bonus_factors()
+    
+    # 計算最終原始分數
+    raw_score = base_score * critical_factor * bonus_factor
+    
+    # 轉���為最終分數（60-95範圍）
+    final_score = 60 + (raw_score * 35)
+    
+    # 確保分數在合理範圍內並保留兩位小數
+    return round(max(60.0, min(95.0, final_score)), 2)
+    
+
+# def amplify_score_extreme(score: float) -> float:
+#     """
+#     改進的分數轉換函數
+#     提供更大的分數範圍和更明顯的差異
+    
+#     轉換邏輯：
+#     - 極差匹配 (0.0-0.3) -> 60-68%
+#     - 較差匹配 (0.3-0.5) -> 68-75%
+#     - 中等匹配 (0.5-0.7) -> 75-85%
+#     - 良好匹配 (0.7-0.85) -> 85-92%
+#     - 優秀匹配 (0.85-1.0) -> 92-95%
+#     """
+#     if score < 0.3:
+#         # 極差匹配：快速線性增長
+#         return 0.60 + (score / 0.3) * 0.08
+#     elif score < 0.5:
+#         # 較差匹配：緩慢增長
+#         position = (score - 0.3) / 0.2
+#         return 0.68 + position * 0.07
+#     elif score < 0.7:
+#         # 中等匹配：穩定線性增長
+#         position = (score - 0.5) / 0.2
+#         return 0.75 + position * 0.10
+#     elif score < 0.85:
+#         # 良好匹配：加速增長
+#         position = (score - 0.7) / 0.15
+#         return 0.85 + position * 0.07
+#     else:
+#         # 優秀匹配：最後衝刺
+#         position = (score - 0.85) / 0.15
+#         return 0.92 + position * 0.03
+
 
 def amplify_score_extreme(score: float) -> float:
     """
-    改進的分數轉換函數
-    提供更大的分數範圍和更明顯的差異
-    
-    轉換邏輯：
-    - 極差匹配 (0.0-0.3) -> 60-68%
-    - 較差匹配 (0.3-0.5) -> 68-75%
-    - 中等匹配 (0.5-0.7) -> 75-85%
-    - 良好匹配 (0.7-0.85) -> 85-92%
-    - 優秀匹配 (0.85-1.0) -> 92-95%
+    將原始相容性分數（0-1）轉換為最終評分（60-95）
+    
+    這個函數負責：
+    1. 將內部計算的原始分數轉換為更有意義的最終分數
+    2. 確保分數分布更自然且有區別性
+    3. 突出極佳和極差的匹配
+    4. 避免分數過度集中在中間區域
+    
+    轉換策略：
+    - 極佳匹配（0.85-1.0）：轉換為 90-95 分
+    - 優良匹配（0.70-0.85）：轉換為 85-90 分
+    - 良好匹配（0.55-0.70）：轉換為 75-85 分
+    - 一般匹配（0.40-0.55）：轉換為 70-75 分
+    - 勉強匹配（0.25-0.40）：轉換為 65-70 分
+    - 不推薦匹配（0-0.25）：轉換為 60-65 分
+    
+    Parameters:
+    -----------
+    score: 原始相容性分數（0.0-1.0）
+    
+    Returns:
+    --------
+    float: 轉換後的最終分數（60.0-95.0）
     """
-    if score < 0.3:
-        # 極差匹配：快速線性增長
-        return 0.60 + (score / 0.3) * 0.08
-    elif score < 0.5:
-        # 較差匹配：緩慢增長
-        position = (score - 0.3) / 0.2
-        return 0.68 + position * 0.07
-    elif score < 0.7:
-        # 中等匹配：穩定線性增長
-        position = (score - 0.5) / 0.2
-        return 0.75 + position * 0.10
-    elif score < 0.85:
-        # 良好匹配：加速增長
-        position = (score - 0.7) / 0.15
-        return 0.85 + position * 0.07
-    else:
-        # 優秀匹配：最後衝刺
+    # 使用分段函數進行更自然的轉換
+    if score >= 0.85:
+        # 極佳匹配：90-95分
         position = (score - 0.85) / 0.15
-        return 0.92 + position * 0.03
+        return 90.0 + (position * 5.0)
+    elif score >= 0.70:
+        # 優良匹配：85-90分
+        position = (score - 0.70) / 0.15
+        return 85.0 + (position * 5.0)
+    elif score >= 0.55:
+        # 良好匹配：75-85分
+        position = (score - 0.55) / 0.15
+        return 75.0 + (position * 10.0)
+    elif score >= 0.40:
+        # 一般匹配：70-75分
+        position = (score - 0.40) / 0.15
+        return 70.0 + (position * 5.0)
+    elif score >= 0.25:
+        # 勉強匹配：65-70分
+        position = (score - 0.25) / 0.15
+        return 65.0 + (position * 5.0)
+    else:
+        # 不推薦匹配：60-65分
+        position = score / 0.25
+        return 60.0 + (position * 5.0)