import asyncio
import time
from services.audio_session import AudioSession
from utils.logger import session_logger
from config import settings
from services.device_config import device_config_manager
from utils.language_detector import LanguageDetector

async def handle_transcription(session: AudioSession, device_id: str, session_id: str):
    start_time = time.perf_counter()
    transcript = session.transcript
    if transcript:
        session_logger.info(device_id, session_id, f"最终转录结果: {transcript}")
        detected_language = await LanguageDetector.detect_language(transcript)
        session_logger.info(device_id, session_id, f"检测到的语言: {detected_language}")
        device_config = await device_config_manager.get_config(device_id)
        preferred_language = None
        if device_config and hasattr(device_config, 'preferred_language') and device_config.preferred_language:
            preferred_language = device_config.preferred_language
        effective_language = detected_language or preferred_language
        if detected_language and (not preferred_language or detected_language != preferred_language):
            session_logger.info(
                device_id,
                session_id,
                f"使用检测到的语言: {detected_language}"
            )
        elif preferred_language and detected_language != preferred_language:
            session_logger.info(
                device_id,
                session_id,
                f"检测到语言 {detected_language}，但使用首选语言: {preferred_language}"
            )
        
        from services.conversation_history import (
            DeviceConversationHistory,
            conversation_history_manager,
        )
        from handlers.command_handler import get_device_role
        selected_role = await get_device_role(device_id, effective_language)
        role_key = selected_role.get("role_key") or settings.selected_role_key
        device_history = await conversation_history_manager.get_history(device_id, role_key)
        if not device_history:
            device_history = DeviceConversationHistory()
            await conversation_history_manager.set_history(device_id, device_history, role_key)
        device_history.last_interaction_time = asyncio.get_running_loop().time()
        history = device_history.history[-settings.max_conversation_history :]
        
        from handlers.response_processor import generate_and_process_response
        resp_start_time = time.perf_counter()
        await generate_and_process_response(
            transcript,
            history,
            selected_role,
            device_id,
            session_id,
            device_history,
            session,
            effective_language,
        )
        resp_end_time = time.perf_counter()
        session_logger.info(
            device_id,
            session_id,
            f"回复生成和处理 耗时: {resp_end_time - resp_start_time:.2f} 秒",
        )
    else:
        session_logger.error("unknown", "unknown", "未收到转录结果")
        from handlers.prompt_sound_handler import handle_prompt_sound_request
        await handle_prompt_sound_request(device_id, "tts_error")
        from services.tts_error_manager import tts_error_manager
        await tts_error_manager.end_tts_session(device_id, session_id)
    end_time = time.perf_counter()
    session_logger.info(
        device_id, session_id, f"总处理 耗时: {end_time - start_time:.2f} 秒"
    )