Tolan/backend/ai_service.py

"""
AI服务：集成STT、LLM、TTS模型
"""
import base64
import json
import asyncio
import tempfile
import os
from typing import AsyncGenerator, Optional
import dashscope
from openai import OpenAI
from config import settings
from models import EmotionType

# 🔥 TTS API选择
# 注意: SpeechSynthesizer (tts_v2) 使用callback模式，不适合我们的generator流式场景
# MultiModalConversation 已经是最适合流式语音合成的API
USE_NEW_TTS_API = False  # 保持使用 MultiModalConversation
print("ℹ️  使用 MultiModalConversation API (支持真正的流式generator)")

# 设置API Key
dashscope.api_key = settings.dashscope_api_key


class AIService:
    """AI服务管理器"""
    
    # 类级别的预热标记（避免多次实例化时重复预热）
    _tts_warmed_up = False
    _warmup_lock = None
    _tts_call_lock = None  # TTS调用锁（防止SDK内部冲突）
    _last_tts_call_time = 0.0  # 上次TTS调用时间（用于速率控制）
    
    def __init__(self):
        import httpx
        import os
        
        # 临时清除代理环境变量（只在这个进程中）
        env_backup = {}
        proxy_vars = ['HTTP_PROXY', 'HTTPS_PROXY', 'http_proxy', 'https_proxy', 'ALL_PROXY', 'all_proxy']
        for var in proxy_vars:
            if var in os.environ:
                env_backup[var] = os.environ[var]
                del os.environ[var]
        
        # 🔥 优化：创建高性能 HTTP 客户端 - 增加连接池配置
        http_client = httpx.Client(
            proxy=None,  # 禁用代理
            timeout=60.0,
            trust_env=False,  # 不信任环境变量中的代理设置
            # 连接池优化
            limits=httpx.Limits(
                max_keepalive_connections=20,  # 增加keepalive连接数（默认10）
                max_connections=50,  # 增加总连接数（默认20）
                keepalive_expiry=30.0,  # keepalive过期时间30秒
            ),
            # HTTP/2支持 - 多路复用，减少连接开销
            http2=True,
        )
        
        self.openai_client = OpenAI(
            api_key=settings.dashscope_api_key,
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            http_client=http_client,  # 使用自定义 HTTP 客户端
        )
        
        # 🔥 TTS优化：预热TTS连接（后台执行，不阻塞启动）
        import threading
        
        # 初始化锁
        if AIService._warmup_lock is None:
            AIService._warmup_lock = threading.Lock()
            AIService._tts_call_lock = threading.Lock()  # 初始化TTS调用锁
        
        # 只预热一次（避免多次实例化时重复）
        if not AIService._tts_warmed_up:
            threading.Thread(target=self._warmup_tts_sync, daemon=True).start()
        
        # 恢复环境变量（避免影响其他模块）
        for var, value in env_backup.items():
            os.environ[var] = value
    
    def _warmup_tts_sync(self):
        """同步方式预热TTS连接（在后台线程执行）"""
        import time
        
        # 使用锁确保只预热一次
        with AIService._warmup_lock:
            if AIService._tts_warmed_up:
                return  # 已经预热过了
            
            time.sleep(2)  # 等待2秒确保服务启动完成
            
            try:
                print("\n🔥 开始预热TTS连接...")
                start_time = time.time()
                
                response = dashscope.MultiModalConversation.call(
                    model=settings.tts_model,
                    text="Hi",  # 极短的测试文本
                    voice=settings.tts_voice,
                    stream=True,
                )
                
                # 只接收首块即停止
                for _ in response:
                    break
                
                elapsed = (time.time() - start_time) * 1000
                print(f"✅ TTS连接预热完成（耗时: {elapsed:.0f}ms）")
                print(f"   后续TTS调用将复用此连接，减少延迟\n")
                
                AIService._tts_warmed_up = True  # 标记为已预热
                
            except Exception as e:
                print(f"⚠️  TTS预热失败（不影响正常使用）: {e}\n")
    
    # STT现在使用流式识别，在websocket_handler中直接处理
    
    async def generate_response_stream(
        self, user_text: str
    ) -> AsyncGenerator[tuple[str, EmotionType], None]:
        """
        生成对话回复（流式）
        
        Args:
            user_text: 用户输入文本
            
        Yields:
            (sentence, emotion): 句子片段和情感
        """
        try:
            print(f"\n========== LLM 流式开始 ==========")
            print(f"用户输入: {user_text}")
            
            # 构建System Prompt
            system_prompt = self._build_system_prompt()
            
            print(f"调用 LLM 流式: {settings.llm_model}")
            print(f"学习者水平: {settings.LEARNER_PROFICIENCY}, 年龄组: {settings.AGE_TAG}, 主题: {settings.TOPIC_TAG}, 模式: {settings.EXPERIMENT_TAG}")
            
            # 调用LLM流式API
            response = self.openai_client.chat.completions.create(
                model=settings.llm_model,
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": user_text},
                ],
                temperature=0.7,
                max_tokens=500,
                stream=True,  # 启用流式
            )
            
            buffer = ""
            full_response = ""
            sentence_count = 0
            detected_emotion: EmotionType = "neutral"  # 存储检测到的情感
            emotion_yielded = False  # 标记是否已发送情感
            
            for chunk in response:
                if chunk.choices[0].delta.content:
                    content = chunk.choices[0].delta.content
                    buffer += content
                    full_response += content
                    
                    # 🎯 优先检测情感标记（如果还没检测到）
                    if detected_emotion == "neutral" and "[EMOTION:" in full_response:
                        emotion_start = full_response.find("[EMOTION:")
                        emotion_end = full_response.find("]", emotion_start)
                        if emotion_end > emotion_start:
                            emotion_str = full_response[emotion_start + 9:emotion_end].strip().lower()
                            valid_emotions = ["neutral", "happy", "sad", "excited", "angry", "surprised", "thoughtful", "encouraging", "confused", "worried", "satisfied", "friendly", "sorry"]
                            if emotion_str in valid_emotions:
                                detected_emotion = emotion_str
                                print(f"🎭 流式检测到情感: {detected_emotion}")
                                
                                # 🚀 立即 yield 空句子传递情感（减少延迟）
                                if not emotion_yielded:
                                    print(f"⚡ 立即发送情感标记（无需等待完整句子）")
                                    yield ("", detected_emotion)  # 空句子，仅传递情感
                                    emotion_yielded = True
                                    
                                    # 🧹 从 buffer 中移除情感标记（避免重复处理）
                                    buffer = buffer.replace(f"[EMOTION:{emotion_str.upper()}]", "").strip()
                    
                    # 检测句子边界（完整的句子）
                    if self._is_complete_sentence(buffer):
                        sentence = buffer.strip()
                        sentence_count += 1
                        print(f"LLM 流式输出句子{sentence_count}: {sentence}")
                        # 使用已检测到的情感
                        yield (sentence, detected_emotion)
                        buffer = ""
            
            # 处理剩余内容（使用已检测到的情感）
            # 从完整响应中移除情感标签部分（用于日志输出）
            clean_response = full_response
            if "[EMOTION:" in full_response:
                emotion_start = full_response.find("[EMOTION:")
                clean_response = full_response[:emotion_start].strip()
            
            # 处理buffer中的剩余内容（已输出句子之后的部分）
            remaining = buffer.strip()
            if remaining and not remaining.startswith("[EMOTION"):
                sentence_count += 1
                print(f"LLM 流式输出句子{sentence_count}: {remaining}")
                yield (remaining, detected_emotion)
            elif not remaining and sentence_count == 0:
                # 如果一个句子都没输出，输出完整内容
                if clean_response:
                    print(f"LLM 流式输出完整: {clean_response}")
                    yield (clean_response, detected_emotion)
            
            print(f"LLM 完整响应: {clean_response}")
            print(f"提取情感: {detected_emotion}")
            print(f"========== LLM 流式成功 ==========\n")
            
        except Exception as e:
            print(f"========== LLM 流式错误 ==========")
            print(f"错误: {e}")
            import traceback
            traceback.print_exc()
            print(f"========== LLM 流式错误结束 ==========\n")
            yield ("I'm sorry, I'm having trouble understanding. Could you please repeat that?", "neutral")
    
    def _is_complete_sentence(self, text: str) -> bool:
        """检测是否完整句子"""
        text = text.strip()
        
        # 必须以句子结束符结尾
        if not text.endswith(('.', '!', '?', '。', '！', '？')):
            return False
        
        # 排除常见缩写（避免误判）
        words = text.split()
        if words:
            last_word = words[-1]
            # 常见英文缩写
            common_abbrev = ['Mr.', 'Mrs.', 'Ms.', 'Dr.', 'Prof.', 'Sr.', 'Jr.', 'etc.', 'e.g.', 'i.e.', 'vs.']
            if last_word in common_abbrev:
                return False
        
        # 🔥 优化：减少最小字符限制从5到3，让短句更快发送
        # 例如"Hi!" "OK!" "Yes!" 这种短句也能快速返回
        if len(text) < 3:
            return False
        
        return True
    
    async def generate_response(
        self, user_text: str
    ) -> tuple[str, EmotionType]:
        """
        生成对话回复
        
        Args:
            user_text: 用户输入文本
            
        Returns:
            (response_text, emotion): 回复文本和情感
        """
        try:
            print(f"\n========== LLM 开始 ==========")
            print(f"用户输入: {user_text}")
            
            # 构建System Prompt
            system_prompt = self._build_system_prompt()
            
            print(f"调用 LLM: {settings.llm_model}")
            print(f"学习者水平: {settings.LEARNER_PROFICIENCY}, 年龄组: {settings.AGE_TAG}, 主题: {settings.TOPIC_TAG}, 模式: {settings.EXPERIMENT_TAG}")
            
            # 调用LLM
            response = self.openai_client.chat.completions.create(
                model=settings.llm_model,
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": user_text},
                ],
                temperature=0.7,
                max_tokens=500,
            )
            
            full_response = response.choices[0].message.content or ""
            print(f"LLM 原始响应: {full_response}")
            
            # 提取情感标签
            emotion: EmotionType = "neutral"
            response_text = full_response
            
            # 查找情感标签
            if "[EMOTION:" in full_response:
                emotion_start = full_response.find("[EMOTION:")
                emotion_end = full_response.find("]", emotion_start)
                if emotion_end > emotion_start:
                    emotion_str = full_response[emotion_start + 9:emotion_end].strip().lower()
                    # 验证情感类型
                    valid_emotions = ["neutral", "happy", "sad", "excited", "angry", "surprised", "thoughtful", "encouraging", "confused", "worried", "satisfied", "friendly", "sorry"]
                    if emotion_str in valid_emotions:
                        emotion = emotion_str
                        print(f"提取到情感标签: {emotion}")
                    # 移除情感标签（不发送给TTS）
                    response_text = full_response[:emotion_start].strip()
                    print(f"已移除情感标签，纯文本内容: {response_text}")
            
            # 如果没有文本内容，使用默认回复
            if not response_text:
                response_text = "I understand. Please tell me more!"
                emotion = "neutral"
            
            print(f"✅ 将发送给TTS的文本: {response_text}")
            print(f"✅ 情感: {emotion}")
            print(f"========== LLM 成功 ==========\n")
            
            return (response_text, emotion)
            
        except Exception as e:
            print(f"========== LLM 错误 ==========")
            print(f"错误: {e}")
            import traceback
            traceback.print_exc()
            print(f"========== LLM 错误结束 ==========\n")
            return ("I'm sorry, I'm having trouble understanding. Could you please repeat that?", "neutral")
    
    async def text_to_speech_stream(
        self, text: str, emotion: EmotionType = "neutral"
    ) -> AsyncGenerator[bytes, None]:
        """
        文本转语音（流式 - 实时返回音频块），带重试机制和速率控制
        
        Args:
            text: 要合成的文本
            emotion: 情感类型
            
        Yields:
            audio_data: PCM 音频数据块（Base64 解码后的原始数据）
        """
        import time
        
        # 🚦 速率控制：确保两次TTS调用之间有最小间隔
        min_interval = settings.TTS_MIN_INTERVAL
        time_since_last_call = time.time() - AIService._last_tts_call_time
        
        if time_since_last_call < min_interval:
            wait_time = min_interval - time_since_last_call
            print(f"🚦 TTS速率控制：等待 {wait_time:.2f}秒以避免触发API限制...")
            await asyncio.sleep(wait_time)
        
        # 更新最后调用时间
        AIService._last_tts_call_time = time.time()
        
        max_retries = settings.TTS_MAX_RETRIES
        retry_delay = settings.TTS_RETRY_DELAY
        backoff = settings.TTS_RETRY_BACKOFF
        
        for attempt in range(max_retries + 1):
            try:
                async for audio_chunk in self._text_to_speech_stream_internal(text, emotion):
                    yield audio_chunk
                # 成功则退出
                return
                
            except Exception as e:
                # 检查是否为速率限制错误（429、Throttling、rate limit）
                error_str = str(e)
                is_rate_limit = (
                    'rate limit' in error_str.lower() or 
                    'throttling' in error_str.lower() or 
                    '429' in error_str or
                    'RateQuota' in error_str
                )
                
                if is_rate_limit and attempt < max_retries:
                    wait_time = retry_delay * (backoff ** attempt)
                    print(f"⚠️ TTS API速率限制 (尝试 {attempt + 1}/{max_retries + 1})，等待 {wait_time:.1f}秒后重试...")
                    await asyncio.sleep(wait_time)
                    continue
                else:
                    # 非速率限制错误或已达最大重试次数
                    if is_rate_limit and attempt == max_retries:
                        print(f"❌ TTS重试失败，已达最大重试次数 ({max_retries + 1})")
                    raise
    
    async def _text_to_speech_stream_internal(
        self, text: str, emotion: EmotionType = "neutral"
    ) -> AsyncGenerator[bytes, None]:
        """
        TTS流式调用的内部实现（不含重试逻辑）
        
        Args:
            text: 要合成的文本
            emotion: 情感类型
            
        Yields:
            audio_data: PCM 音频数据块（Base64 解码后的原始数据）
        """
        try:
            import time
            tts_start = time.time()
            
            print(f"\n========== TTS 流式开始 ==========")
            print(f"要合成的文本: {text}")
            print(f"情感: {emotion}")
            
            # 根据情感选择音色
            voice = self._get_voice_for_emotion(emotion)
            print(f"使用音色: {voice}")
            print(f"TTS模型: {settings.tts_model}")
            print(f"语速: {settings.tts_speech_rate}x (1.0=正常)")
            print(f"流式模式: 是 (PCM 24kHz)")
            
            # 🔥 TTS优化：使用流式API + 优化参数
            print(f"API类型: MultiModalConversation (流式TTS)")
            
            def sync_streaming_tts():
                return dashscope.MultiModalConversation.call(
                    model=settings.tts_model,
                    text=text,
                    voice=voice,
                    speech_rate=settings.tts_speech_rate,  # 语速调整
                    stream=True,  # 流式输出
                    # 注意: incremental_output 参数在此API中可能不生效
                )
            
            print("调用 DashScope TTS 流式 API...")
            
            # 🔥 修复：使用队列在线程和异步之间传递数据
            import queue
            import threading
            
            audio_queue = queue.Queue()
            error_holder = [None]  # 用列表包装以便在线程间共享
            
            def stream_producer():
                """在独立线程中执行同步流式API调用"""
                nonlocal chunk_count, first_chunk_time, total_audio_size
                try:
                    print(f"🧵 生产者线程启动 (线程ID: {threading.current_thread().ident})")
                    
                    # 🔥 关键修复：在锁内完成整个API调用和迭代
                    # 原因：DashScope SDK内部可能有全局状态，并发迭代会冲突
                    with AIService._tts_call_lock:
                        print(f"🔒 获取TTS调用锁，开始API调用...")
                        response = sync_streaming_tts()
                        print(f"✅ TTS API调用成功，开始迭代响应...")
                        
                        chunk_index = 0
                        for chunk in response:
                            chunk_index += 1
                            print(f"🔍 收到chunk#{chunk_index}: {type(chunk)}")
                            
                            # 调试：打印chunk结构
                            if hasattr(chunk, 'status_code'):
                                print(f"   - status_code: {chunk.status_code}")
                            if hasattr(chunk, 'code'):
                                print(f"   - code: {chunk.code}")
                            if hasattr(chunk, 'message'):
                                print(f"   - message: {chunk.message}")
                            
                            # 🔥 检查API错误（特别是速率限制）
                            if hasattr(chunk, 'status_code') and chunk.status_code != 200:
                                error_code = getattr(chunk, 'code', 'Unknown')
                                error_msg = getattr(chunk, 'message', 'No error message')
                                
                                # 构造友好的错误信息
                                if chunk.status_code == 429 or 'Throttling' in error_code:
                                    raise Exception(f"TTS API速率限制: {error_msg} (code: {error_code})")
                                else:
                                    raise Exception(f"TTS API错误 (status={chunk.status_code}): {error_msg} (code: {error_code})")
                            
                            if hasattr(chunk, 'output'):
                                print(f"   - has output: True")
                                if hasattr(chunk.output, 'audio'):
                                    print(f"   - has audio: True")
                                else:
                                    print(f"   - has audio: False")
                                    print(f"   - output attributes: {dir(chunk.output)}")
                            else:
                                print(f"   - has output: False")
                                print(f"   - chunk attributes: {dir(chunk)}")
                            
                            if hasattr(chunk, 'output') and hasattr(chunk.output, 'audio'):
                                audio = chunk.output.audio
                                
                                # 接收到音频数据块
                                if audio.data is not None:
                                    # 记录首字节时间
                                    if first_chunk_time is None:
                                        first_chunk_time = time.time()
                                        first_byte_latency = (first_chunk_time - tts_start) * 1000
                                        print(f"⚡ 首字节延迟: {first_byte_latency:.1f}ms")
                                    
                                    # Base64 解码 PCM 数据
                                    pcm_bytes = base64.b64decode(audio.data)
                                    chunk_count += 1
                                    total_audio_size += len(pcm_bytes)
                                    
                                    # 定期打印进度（每10块）
                                    if chunk_count % 10 == 0:
                                        elapsed = (time.time() - tts_start) * 1000
                                        print(f"   📦 块#{chunk_count}: {len(pcm_bytes)}字节 (耗时: {elapsed:.0f}ms)")
                                    
                                    # 放入队列
                                    audio_queue.put(('data', pcm_bytes))
                                
                                # 检查是否结束
                                if hasattr(chunk.output, 'finish_reason') and chunk.output.finish_reason == "stop":
                                    tts_end = time.time()
                                    total_duration = (tts_end - tts_start) * 1000
                                    
                                    print(f"✅ TTS 流式完成:")
                                    print(f"   - 总块数: {chunk_count}")
                                    print(f"   - 音频大小: {total_audio_size} 字节 ({total_audio_size/1024:.1f}KB)")
                                    print(f"   - 总耗时: {total_duration:.0f}ms")
                                    if first_chunk_time:
                                        first_byte_ms = (first_chunk_time - tts_start) * 1000
                                        print(f"   - 首字节延迟: {first_byte_ms:.0f}ms")
                                        if first_byte_ms < 300:
                                            print(f"   - ✅ 首字节延迟达标 (<300ms)")
                                        else:
                                            print(f"   - ⚠️  首字节延迟未达标 (目标<300ms)")
                                    
                                    # 完整音频 URL（可选，用于备份）
                                    if hasattr(audio, 'url') and audio.url:
                                        print(f"   - 完整音频 URL: {audio.url}")
                                    if hasattr(audio, 'expires_at') and audio.expires_at:
                                        print(f"   - 过期时间: {audio.expires_at}")
                                    
                                    print(f"========== TTS 流式成功 ==========\n")
                                    break
                    
                    # 标记完成
                    print(f"🧵 生产者线程完成，共处理 {chunk_count} 个音频块")
                    audio_queue.put(('done', None))
                    
                except Exception as e:
                    print(f"🧵 生产者线程错误: {e}")
                    import traceback
                    traceback.print_exc()
                    error_holder[0] = e
                    audio_queue.put(('error', e))
            
            # 启动生产者线程
            chunk_count = 0
            first_chunk_time = None
            total_audio_size = 0
            received_data = False  # 标记是否收到过数据
            
            producer_thread = threading.Thread(target=stream_producer, daemon=True)
            producer_thread.start()
            print(f"🎬 生产者线程已启动，等待音频数据...")
            
            # 异步消费队列数据
            while True:
                # 非阻塞获取（避免阻塞事件循环）
                try:
                    msg_type, data = await asyncio.to_thread(audio_queue.get, timeout=30)
                    print(f"📥 收到队列消息: {msg_type}")
                    
                    if msg_type == 'data':
                        received_data = True
                        yield data
                        await asyncio.sleep(0)  # 让出控制权
                    elif msg_type == 'done':
                        break
                    elif msg_type == 'error':
                        raise data
                        
                except queue.Empty:
                    raise Exception("TTS API 超时（30秒无响应）")
            
            # 检查是否收到过数据（避免竞态条件）
            if not received_data:
                error_msg = f"TTS API 未返回任何音频数据 (text='{text}', emotion={emotion}, voice={voice})"
                if error_holder[0]:
                    error_msg += f"\n生产者线程错误: {error_holder[0]}"
                raise Exception(error_msg)
                
        except Exception as e:
            print(f"========== TTS 流式错误 ==========")
            print(f"错误: {e}")
            import traceback
            traceback.print_exc()
            print(f"========== TTS 流式错误结束 ==========\n")
            raise
    
    def _get_voice_for_emotion(self, emotion: EmotionType) -> str:
        """根据情感选择音色"""
        # 所有情感统一使用配置文件中的音色
        return settings.tts_voice
    
    def _build_system_prompt(self) -> str:
        """构建System Prompt"""
        learner_proficiency = settings.LEARNER_PROFICIENCY
        age_tag = settings.AGE_TAG
        topic_tag = settings.TOPIC_TAG
        experiment_tag = settings.EXPERIMENT_TAG
        
        # 🔥 如果启用简化提示词（优化延迟）
        if settings.USE_SIMPLIFIED_PROMPT:
            return self._build_simplified_prompt(learner_proficiency, age_tag, topic_tag, experiment_tag)
        
        # 基础提示词
        prompt = f"""**[Role]** 
You are **KELLY**, a friendly and supportive English conversation partner based in London.

**[Objective]** 
Help Chinese EFL learners practice **spoken English**.

**[Target Audience]**
- Language Level: **{learner_proficiency}**
- Age Group: **{age_tag}**
- Conversation Topic: **{topic_tag}**

**[Response Guidelines]**
1. **Lead the Conversation**: Don't just follow the learner's questions—take initiative. Gently guide the conversation forward by introducing related ideas, asking engaging questions, or adding playful input.
2. **Stay Focused**: Keep the conversation on the topic {topic_tag}, and make it suitable for {age_tag} learners.
3. **Be Concise**: Respond in 2–3 short, natural sentences—like small talk with a friend.
4. **Use Simple Language**: Stick to A1-A2 level (very easy) vocabulary and grammar. No idioms, no complex tenses. Use high-frequency, easy words.
5. **Adapt to Learner**: If learners give very short or confused answers, simplify even more: use shorter, clearer sentences.
6. **Spark Real Conversation**: Ask easy follow-up questions that feel personal, imaginative, or reflective (e.g., "What if you could go anywhere?", "How do you feel when...?", "Why do you like it?"). Let the conversation feel playful, personal, and curious.
7. **Transition Smoothly**: If the topic feels finished or the learner seems less engaged, gently move to a related or new topic in a natural way. avoid overly specific or unusual questions (e.g., "What type of fish do you like?" or "What shape is your favorite lamp?"), as these can feel awkward or hard to answer. Instead, use broader, everyday topics that are easier to talk about, like: "That reminds me — do you usually cook at home or eat out?", "Speaking of weekends, do you like relaxing or doing something active?"
8. **Being Empathetic**: Acknowledge the learner's feelings and experiences, but avoid overdoing it. 
9. **Seek Clarification**: When meaning is unclear, use context and ask the learner to clarify. After requesting clarification, pause and wait for their response before continuing the conversation.
10. **Handle Misunderstandings**: 
 - If the learner says "Sorry?" → Rephrase your last sentence in simpler English.
 - If they ask "Do you mean…?" → Confirm their guess and briefly explain in basic terms.
"""
        
        # 如果是实验组，添加纠错反馈策略
        if experiment_tag == "experiment":
            correction_rule = """
**[Corrective Feedback Strategy]**
Goal: 
Prioritising conversation flow while helping learners notice and improve their grammar.

Tone & Guidelines: 
(1) Use a kind and supportive tone: correct gently, and always reinforce progress;
(2) Focus ONLY on grammar errors, ignore vocabulary issues;
(3) Correct ONLY ONE error at a time;
(4) Praise self-corrections (e.g. "I do… I did it last time") — encourage the effort, don't go back to correct the earlier mistake.
(5) Reinforcement: Praise learners' correct usage to build their confidence. Examples: "That's right!", "Good job with the past tense!"
(6) Avoid disrupting the conversation flow — don't say things like 'let's fix it', 'it should be...', 'you made a mistake', or 'you should say...' 

Correction Strategy:
- For **grammar errors** (e.g., tense, agreement): Use **recasts** as the default - restate with correct form naturally; If meaning is unclear: use a clarification check; If repeated 2+ times: use explicit correction in simple and friendly English.
- For **vocabulary errors** (e.g., inappropriate word choice): ONLY use recasts; NEVER explain or point out!

Correction Techniques:
- **Recast** (PREFERRED): For minor grammar mistakes, restate the learner's sentence naturally with the correct form — without pointing out the error or saying "like you said, but…". Example: Learner: "Yesterday I go to restaurant.", You: "Yesterday you **went** to the restaurant? That's great!"
- **Clarification Check**: Ask a confirming question when meaning is unclear. After asking the question, DO NOT continue asking other follow-up questions; instead, wait for the student's clarification. Example: "Do you mean 'you **went** to the restaurant'?" 
- **Explicit Correction**: Only when a grammar mistake repeats many times, you explain the correct form clearly in basic English. After providing an Explicit Correction, DO NOT continue asking the follow-up question; instead, wait for the student's self-correction. If they try to self-correct, respond ONLY to the grammar part and don't focus on vocabulary. Example: "We say 'went' because it's past tense. So it's: 'I went to the restaurant.' Can you try it again?"
"""
            prompt += correction_rule
        
        # 添加情感标签要求（前置到开头）
        prompt += """

**[Emotion Tag - IMPORTANT]**
At the BEGINNING of your response, on the FIRST line, add the emotion tag in this exact format:
[EMOTION:emotion_name]

Then continue with your normal response.

Available emotions: neutral, happy, sad, excited, angry, surprised, thoughtful, encouraging, confused, worried, satisfied, friendly, sorry

**How to choose emotion:**
1. **Respond to the learner's emotion**: If they express sadness/difficulty → use "sorry" or "encouraging"; if they're happy/excited → use "happy" or "excited"
2. **Match your response tone**: The emotion should reflect YOUR response style (empathetic, supportive, cheerful, etc.)
3. **Examples**:
   - Learner says "I'm sad today" → [EMOTION:sorry] "I'm sorry to hear that. What happened?"
   - Learner says "I passed my exam!" → [EMOTION:excited] "That's amazing! Congratulations!"
   - Learner asks a normal question → [EMOTION:friendly] or [EMOTION:neutral]

Example response:
[EMOTION:happy]
That sounds like fun! What did you do there?

CRITICAL: 
- The emotion tag MUST be the FIRST line, before any other content!
- DO NOT use parentheses () or brackets [] in your spoken response (they will be removed during speech synthesis)
- Keep your response natural and conversational, avoid meta-commentary or clarifications in parentheses"""
        
        return prompt
    
    def _build_simplified_prompt(self, learner_proficiency: str, age_tag: str, topic_tag: str, experiment_tag: str) -> str:
        """构建简化版System Prompt（优化延迟，减少token）"""
        prompt = f"""You are KELLY, a friendly English tutor in London.

**Target**: {learner_proficiency} level, {age_tag}, {topic_tag}

**Guidelines**:
1. Lead conversation actively, 2-3 short simple sentences
2. Use A1-A2 level vocabulary only
3. Ask easy, personal follow-up questions
4. If unclear, ask for clarification then wait
5. Transition smoothly between topics
6. Be empathetic but natural
"""
        
        # 实验组：简化的纠错规则
        if experiment_tag == "experiment":
            prompt += """
**Feedback**: 
- Recast grammar errors naturally (one at a time)
- Supportive tone, praise progress
- Never say "you made a mistake"
"""
        
        # 情感标签（必需）
        prompt += """
**Emotion Tag - REQUIRED**: 
Add [EMOTION:name] at the FIRST line before your response.
Emotions: neutral, happy, sad, excited, angry, surprised, thoughtful, encouraging, confused, worried, satisfied, friendly, sorry

**Choose based on**:
- Learner's emotion (sad→sorry/encouraging, happy→excited)
- Your response tone (empathetic, supportive, cheerful)

Example:
[EMOTION:sorry]
I'm sorry to hear that. What happened?

Critical: NO parentheses () or brackets [] in spoken text.
"""
        
        return prompt


# 全局AI服务实例
ai_service = AIService()