breed_recommendation.py

import sqlite3
import gradio as gr
from dog_database import get_dog_description, dog_data
from breed_health_info import breed_health_info
from breed_noise_info import breed_noise_info
from scoring_calculation_system import UserPreferences, calculate_compatibility_score
from recommendation_html_format import format_recommendation_html, get_breed_recommendations
from smart_breed_matcher import SmartBreedMatcher
from description_search_ui import create_description_search_tab

def create_recommendation_tab(UserPreferences, get_breed_recommendations, format_recommendation_html, history_component):

    with gr.TabItem("Breed Recommendation"):
        with gr.Tabs():
            with gr.Tab("Find by Criteria"):
                gr.HTML("<p style='text-align: center;'>Tell us about your lifestyle, and we'll recommend the perfect dog breeds for you!</p>")

                with gr.Row():
                    with gr.Column():
                        living_space = gr.Radio(
                            choices=["apartment", "house_small", "house_large"],
                            label="What type of living space do you have?",
                            info="Choose your current living situation",
                            value="apartment"
                        )

                        exercise_time = gr.Slider(
                            minimum=0,
                            maximum=180,
                            value=60,
                            label="Daily exercise time (minutes)",
                            info="Consider walks, play time, and training"
                        )

                        grooming_commitment = gr.Radio(
                            choices=["low", "medium", "high"],
                            label="Grooming commitment level",
                            info="Low: monthly, Medium: weekly, High: daily",
                            value="medium"
                        )

                    with gr.Column():
                        experience_level = gr.Radio(
                            choices=["beginner", "intermediate", "advanced"],
                            label="Dog ownership experience",
                            info="Be honest - this helps find the right match",
                            value="beginner"
                        )

                        has_children = gr.Checkbox(
                            label="Have children at home",
                            info="Helps recommend child-friendly breeds"
                        )

                        noise_tolerance = gr.Radio(
                            choices=["low", "medium", "high"],
                            label="Noise tolerance level",
                            info="Some breeds are more vocal than others",
                            value="medium"
                        )

                get_recommendations_btn = gr.Button("Find My Perfect Match! 🔍", variant="primary")
                recommendation_output = gr.HTML(label="Breed Recommendations")

            with gr.Tab("Find by Description"):
                description_input, description_search_btn, description_output, processing_message = create_description_search_tab()

    
        def on_find_match_click(*args):
            try:
                user_prefs = UserPreferences(
                    living_space=args[0],
                    exercise_time=args[1],
                    grooming_commitment=args[2],
                    experience_level=args[3],
                    has_children=args[4],
                    noise_tolerance=args[5],
                    space_for_play=True if args[0] != "apartment" else False,
                    other_pets=False,
                    climate="moderate",
                    health_sensitivity="medium",  # 新增: 默認中等敏感度
                    barking_acceptance=args[5]    # 使用 noise_tolerance 作為 barking_acceptance
                )

                recommendations = get_breed_recommendations(user_prefs, top_n=10)

                history_results = [{
                    'breed': rec['breed'],
                    'rank': rec['rank'],
                    'overall_score': rec['final_score'],
                    'base_score': rec['base_score'],
                    'bonus_score': rec['bonus_score'],
                    'scores': rec['scores']
                } for rec in recommendations]

                # 保存到歷史記錄，也需要更新保存的偏好設定
                history_component.save_search(
                    user_preferences={
                        'living_space': args[0],
                        'exercise_time': args[1],
                        'grooming_commitment': args[2],
                        'experience_level': args[3],
                        'has_children': args[4],
                        'noise_tolerance': args[5],
                        'health_sensitivity': "medium",
                        'barking_acceptance': args[5]
                    },
                    results=history_results
                )

                return format_recommendation_html(recommendations)

            except Exception as e:
                print(f"Error in find match: {str(e)}")
                import traceback
                print(traceback.format_exc())
                return "Error getting recommendations"

        def on_description_search(description: str):
            try:
                processing_message.update(visible=True)
                description_output.update(visible=False)
                
                matcher = SmartBreedMatcher(dog_data)
                breed_recommendations = matcher.match_user_preference(description, top_n=10)
                
                print("Creating user preferences...")
                user_prefs = UserPreferences(
                    living_space="apartment" if "apartment" in description.lower() else "house_small",
                    exercise_time=60,
                    grooming_commitment="medium",
                    experience_level="intermediate",
                    has_children="children" in description.lower() or "kids" in description.lower(),
                    noise_tolerance="medium",
                    space_for_play=True if "yard" in description.lower() or "garden" in description.lower() else False,
                    other_pets=False,
                    climate="moderate",
                    health_sensitivity="medium",
                    barking_acceptance=None
                )

                final_recommendations = []
                
                for smart_rec in breed_recommendations:
                    breed_name = smart_rec['breed']
                    breed_info = get_dog_description(breed_name)
                    if not isinstance(breed_info, dict):
                        continue
                        
                    # 計算基礎相容性分數
                    compatibility_scores = calculate_compatibility_score(breed_info, user_prefs)
                    
                    # 最終分數計算
                    is_preferred = smart_rec.get('is_preferred', False)
                    base_score = compatibility_scores.get('overall', 0.7)
                    smart_score = smart_rec['score']
                    
                    # 根據是否為偏好品種調整分數
                    if is_preferred:
                        final_score = 0.95  # 確保最高分
                    else:
                        # 相似品種的分數計算
                        final_score = min(0.90, (base_score * 0.6 + smart_score * 0.4))
                    
                    final_recommendations.append({
                        'rank': 0,  # 稍後更新
                        'breed': breed_name,
                        'base_score': round(base_score, 4),
                        'smart_match_score': round(smart_score, 4),
                        'final_score': round(final_score, 4),
                        'scores': compatibility_scores,
                        'match_reason': smart_rec['reason'],
                        'info': breed_info,
                        'noise_info': breed_noise_info.get(breed_name, {}),
                        'health_info': breed_health_info.get(breed_name, {})
                    })
                
                # 根據final_score重新排序
                final_recommendations.sort(key=lambda x: (-x['final_score'], x['breed']))
                
                # 更新排名
                for i, rec in enumerate(final_recommendations, 1):
                    rec['rank'] = i
                
                # 驗證排序
                print("\nFinal Rankings:")
                for rec in final_recommendations:
                    print(f"#{rec['rank']} {rec['breed']}")
                    print(f"Base Score: {rec['base_score']:.4f}")
                    print(f"Smart Match Score: {rec['smart_match_score']:.4f}")
                    print(f"Final Score: {rec['final_score']:.4f}")
                    print(f"Reason: {rec['match_reason']}\n")
                    
                    # 確保分數按降序排列
                    if rec['rank'] > 1:
                        prev_score = final_recommendations[rec['rank']-2]['final_score']
                        if rec['final_score'] > prev_score:
                            print(f"Warning: Ranking inconsistency detected!")
                            print(f"#{rec['rank']-1} score: {prev_score:.4f}")
                            print(f"#{rec['rank']} score: {rec['final_score']:.4f}")

                processing_message.update(visible=False)
                description_output.update(visible=True)
                
                return format_recommendation_html(final_recommendations)
                
            except Exception as e:
                processing_message.update(visible=False)
                description_output.update(visible=True)
                
                import traceback
                error_details = traceback.format_exc()
                print(f"Detailed error:\n{error_details}")
                return f"Error processing your description. Details: {str(e)}"


        get_recommendations_btn.click(
            fn=on_find_match_click,
            inputs=[
                living_space,
                exercise_time,
                grooming_commitment,
                experience_level,
                has_children,
                noise_tolerance
            ],
            outputs=recommendation_output
        )

        description_search_btn.click(
            fn=on_description_search,
            inputs=[description_input],
            outputs=[description_output]
        )

    return {
        'living_space': living_space,
        'exercise_time': exercise_time,
        'grooming_commitment': grooming_commitment,
        'experience_level': experience_level,
        'has_children': has_children,
        'noise_tolerance': noise_tolerance,
        'get_recommendations_btn': get_recommendations_btn,
        'recommendation_output': recommendation_output,
        'description_input': description_input,
        'description_search_btn': description_search_btn,
        'description_output': description_output,
        'processing_message': processing_message
    }