import sys
import asyncio
import openai
from pathlib import Path
from datetime import datetime, timezone
from typing import Optional
sys.path.append(str(Path(__file__).resolve().parent.parent))
from schema import APIProvider, LLMRequest, LLMResponse, TokensUsage, LLMParameters

async def call_openai_api(llm_request: LLMRequest, llm_parameters: Optional[LLMParameters] = None) -> LLMResponse:
    start_time = datetime.now(timezone.utc)
    client = openai.AsyncOpenAI(
        api_key=llm_request.api_provider.api_key,
        base_url=llm_request.api_provider.base_url
    )
    
    try:
        messages = [{"role": "user", "content": llm_request.prompt}]
        response = await client.chat.completions.create(
            model=llm_request.api_provider.model_id,
            messages=messages,
            temperature=llm_parameters.temperature if llm_parameters else None,
            max_tokens=llm_parameters.max_tokens if llm_parameters else None,
            top_p=llm_parameters.top_p if llm_parameters else None,
            frequency_penalty=llm_parameters.frequency_penalty if llm_parameters else None,
            presence_penalty=llm_parameters.presence_penalty if llm_parameters else None,
            seed=llm_parameters.seed if llm_parameters else None
        )
        
        end_time = datetime.now(timezone.utc)
        duration = (end_time - start_time).total_seconds()
        
        # 处理可能不存在的缓存token字段
        usage = response.usage
        cache_hit = getattr(usage, 'prompt_cache_hit_tokens', None)
        cache_miss = getattr(usage, 'prompt_cache_miss_tokens', None)
        
        tokens_usage = TokensUsage(
            prompt_tokens=usage.prompt_tokens,
            completion_tokens=usage.completion_tokens,
            prompt_cache_hit_tokens=cache_hit,
            prompt_cache_miss_tokens=cache_miss if cache_miss is not None else usage.prompt_tokens
        )
        
        return LLMResponse(
            response_id=response.id,
            tokens_usage=tokens_usage,
            response_content={"content": response.choices[0].message.content},
            total_duration=duration,
            llm_parameters=llm_parameters
        )
    except Exception as e:
        end_time = datetime.now(timezone.utc)
        duration = (end_time - start_time).total_seconds()
        return LLMResponse(
            response_id="error",
            response_content={"error": str(e)},
            total_duration=duration
        )

if __name__ == "__main__":
    from sqlmodel import Session, select
    from global_var import get_sql_engine, init_global_var
    init_global_var("workdir")
    api_state = "1 deepseek-chat"
    with Session(get_sql_engine()) as session:
        api_provider = session.exec(select(APIProvider).where(APIProvider.id == int(api_state.split(" ")[0]))).first()
    llm_request = LLMRequest(
        prompt="你好，世界！",
        api_provider=api_provider
    )
    # 不使用LLM参数调用
    result = asyncio.run(call_openai_api(llm_request))
    print(f"\n不使用LLM参数调用结果: {result}")

    # 使用LLM参数调用
    params = LLMParameters(
        temperature=0.7,
        max_tokens=100
    )
    result = asyncio.run(call_openai_api(llm_request, params))
    print(f"\nOpenAI API 响应: {result}")