# ❌ 舊版的做法 - 3 次 API 調用
async def handle_text_message(event, user_id):
    msg = event.message.text

    # 第 1 次：提取關鍵字
    keywords = extract_keywords_with_gemini(msg, api_key)

    # 第 2 次：Google Custom Search
    results = search_with_google_custom_search(keywords, search_api_key, cx)

    # 第 3 次：總結結果
    summary = summarize_text(result_text, 300)

    # 回傳結果...

用戶: "Python 是什麼？"
Bot: [搜尋結果 + 摘要]

用戶: "它有什麼優點？"  # ❌ Bot 不知道 "它" 指的是 Python

# ❌ 錯誤的做法 - client 會被垃圾回收
def get_or_create_session(self, user_id):
    client = self._create_client()  # 局部變數
    chat = client.chats.create(...)
    return chat  # 函數結束後 client 被關閉！

from google import genai
from google.genai import types
from datetime import datetime, timedelta
from typing import Dict, Tuple, List

class ChatSessionManager:
    def __init__(self, session_timeout_minutes: int = 30):
        self.sessions: Dict[str, dict] = {}
        self.session_timeout = timedelta(minutes=session_timeout_minutes)

        # ✅ 關鍵：創建共享的 client 實例（避免 client closed 錯誤）
        self.client = self._create_client()

    def _create_client(self) -> genai.Client:
        """創建 Vertex AI client"""
        return genai.Client(
            vertexai=True,  # 啟用 Vertex AI
            project=os.getenv('GOOGLE_CLOUD_PROJECT'),
            location=os.getenv('GOOGLE_CLOUD_LOCATION', 'us-central1'),
            http_options=types.HttpOptions(api_version="v1")
        )

    def get_or_create_session(self, user_id: str) -> Tuple[object, List[dict]]:
        """獲取或創建用戶的 chat session"""
        now = datetime.now()

        # 檢查現有 session
        if user_id in self.sessions:
            session_data = self.sessions[user_id]
            if not self._is_session_expired(session_data):
                session_data['last_active'] = now
                return session_data['chat'], session_data['history']

        # 創建新 session with Google Search Grounding
        config = types.GenerateContentConfig(
            temperature=0.7,
            max_output_tokens=2048,
            # ✅ 啟用 Google Search
            tools=[types.Tool(google_search=types.GoogleSearch())],
        )

        # 使用共享的 self.client（不會被關閉）
        chat = self.client.chats.create(
            model="gemini-2.0-flash",
            config=config
        )

        self.sessions[user_id] = {
            'chat': chat,
            'last_active': now,
            'history': [],
            'created_at': now
        }

        return chat, []

async def search_and_answer_with_grounding(
    query: str,
    user_id: str,
    session_manager: ChatSessionManager
) -> dict:
    """使用 Vertex AI Grounding 搜尋並回答問題"""
    try:
        # 獲取或創建 chat session
        chat, history = session_manager.get_or_create_session(user_id)

        # 構建 prompt（繁體中文 + 不使用 markdown）
        prompt = f"""請用台灣用語的繁體中文回答以下問題。
如果需要最新資訊，請搜尋網路並提供準確的答案。
請提供詳細且有用的回答，並確保資訊來源可靠。
請不要使用 markdown 格式（不要用 **、##、- 等符號）。使用純文字回答。

問題：{query}"""

        # 發送訊息（Gemini 會自動決定是否需要搜尋）
        response = chat.send_message(prompt)

        # 記錄到歷史
        session_manager.add_to_history(user_id, "user", query)
        session_manager.add_to_history(user_id, "assistant", response.text)

        # 提取引用來源
        sources = []
        if hasattr(response, 'candidates') and response.candidates:
            candidate = response.candidates[0]
            if hasattr(candidate, 'grounding_metadata'):
                metadata = candidate.grounding_metadata
                if hasattr(metadata, 'grounding_chunks'):
                    for chunk in metadata.grounding_chunks:
                        if hasattr(chunk, 'web'):
                            sources.append({
                                'title': chunk.web.title,
                                'uri': chunk.web.uri
                            })

        return {
            'answer': response.text,
            'sources': sources,
            'has_history': len(history) > 0
        }

    except Exception as e:
        logger.error(f"Grounding search failed: {e}")
        raise

from loader.chat_session import (
    ChatSessionManager,
    search_and_answer_with_grounding,
    format_grounding_response,
    get_session_status_message
)

# 初始化 Session Manager
chat_session_manager = ChatSessionManager(session_timeout_minutes=30)

async def handle_text_message(event: MessageEvent, user_id: str):
    """處理純文字訊息 - 使用 Grounding"""
    msg = event.message.text.strip()

    # 特殊指令
    if msg.lower() in ['/clear', '/清除']:
        chat_session_manager.clear_session(user_id)
        reply_msg = TextSendMessage(text="✅ 對話已重置")
        await line_bot_api.reply_message(event.reply_token, [reply_msg])
        return

    if msg.lower() in ['/status', '/狀態']:
        status_text = get_session_status_message(chat_session_manager, user_id)
        reply_msg = TextSendMessage(text=status_text)
        await line_bot_api.reply_message(event.reply_token, [reply_msg])
        return

    # 使用 Grounding 搜尋和回答
    try:
        result = await search_and_answer_with_grounding(
            query=msg,
            user_id=user_id,
            session_manager=chat_session_manager
        )

        response_text = format_grounding_response(result, include_sources=True)
        reply_msg = TextSendMessage(text=response_text)
        await line_bot_api.reply_message(event.reply_token, [reply_msg])

    except Exception as e:
        logger.error(f"Error in Grounding search: {e}", exc_info=True)
        error_text = "❌ 抱歉，處理您的問題時發生錯誤。請稍後再試。"
        reply_msg = TextSendMessage(text=error_text)
        await line_bot_api.reply_message(event.reply_token, [reply_msg])

# ❌ 錯誤：client 會被垃圾回收
def create_session():
    client = genai.Client(...)
    chat = client.chats.create(...)
    return chat  # client 被關閉，chat 無法使用

# ✅ 正確：共享 client 實例
class Manager:
    def __init__(self):
        self.client = genai.Client(...)  # 只創建一次

    def create_session(self):
        return self.client.chats.create(...)  # 重複使用

chat = client.chats.create(...)
chat.send_message("問題 1")  # 第 1 輪
chat.send_message("問題 2")  # 第 2 輪（自動記住第 1 輪）

prompt = f"""...
請不要使用 markdown 格式（不要用 **、##、- 等符號）。使用純文字回答。
問題：{query}"""