"""OpenAI 格式修复

修复 Cursor 发出的 OpenAI 格式请求和上游返回的响应中的各种兼容性问题：
  请求修复: Cursor 扁平格式 tools → 标准嵌套格式, tool_choice 规范化
  响应修复: reasoningContent → reasoning_content, <think> 标签提取,
           function_call → tool_calls, tool_calls 字段补全, 参数修复
"""

import json
import logging

from utils.http import gen_id
from utils.tool_fixer import normalize_args, repair_str_replace_args
from utils.think_tag import extract_from_text

logger = logging.getLogger(__name__)


# ─── 请求预处理 ───────────────────────────────────


def normalize_request(payload, upstream_model=None):
    """预处理 Cursor 发来的 OpenAI 格式请求"""
    if upstream_model:
        payload['model'] = upstream_model

    # Cursor 可能在 CC 端点发送 Anthropic 格式的 tool_use/tool_result 消息
    if 'messages' in payload:
        payload['messages'] = _convert_anthropic_messages(payload['messages'])

    if 'tools' not in payload:
        return payload

    # 修复 Cursor 可能发出的扁平格式 tools
    normalized = []
    for tool in payload['tools']:
        if tool.get('type') == 'function' and 'function' in tool:
            normalized.append(tool)
        elif 'name' in tool:
            normalized.append({
                'type': 'function',
                'function': {
                    'name': tool.get('name', ''),
                    'description': tool.get('description', ''),
                    'parameters': tool.get('input_schema')
                                  or tool.get('parameters')
                                  or {'type': 'object', 'properties': {}},
                },
            })
        else:
            normalized.append(tool)
    payload['tools'] = normalized

    # tool_choice 规范化
    tc = payload.get('tool_choice')
    if isinstance(tc, dict):
        if tc.get('type') == 'auto':
            payload['tool_choice'] = 'auto'
        elif tc.get('type') == 'any':
            payload['tool_choice'] = 'required'

    return payload


def _convert_anthropic_messages(messages):
    """将消息中的 Anthropic 格式 tool_use/tool_result 转为 OpenAI 格式

    Cursor 有时在 CC 端点中发送 Anthropic 风格的内容块：
      assistant: [{"type":"tool_use", "id":"...", "name":"Read", "input":{...}}]
      user:      [{"type":"tool_result", "tool_use_id":"...", "content":[...]}]
    OpenAI 格式应为：
      assistant: {"tool_calls":[{"id":"...", "function":{"name":"Read","arguments":"..."}}]}
      tool:      {"tool_call_id":"...", "content":"..."}
    """
    converted = []
    for msg in messages:
        content = msg.get('content')
        if not isinstance(content, list):
            converted.append(msg)
            continue

        has_tool_use = any(
            isinstance(b, dict) and b.get('type') == 'tool_use' for b in content
        )
        has_tool_result = any(
            isinstance(b, dict) and b.get('type') == 'tool_result' for b in content
        )

        if not has_tool_use and not has_tool_result:
            converted.append(msg)
            continue

        role = msg.get('role', '')

        if role == 'assistant' and has_tool_use:
            text_parts = []
            tool_calls = []
            for block in content:
                if not isinstance(block, dict):
                    continue
                if block.get('type') == 'text':
                    text_parts.append(block.get('text', ''))
                elif block.get('type') == 'tool_use':
                    tool_calls.append({
                        'id': block.get('id', gen_id('call_')),
                        'type': 'function',
                        'function': {
                            'name': block.get('name', ''),
                            'arguments': json.dumps(
                                block.get('input', {}), ensure_ascii=False
                            ),
                        },
                    })
            new_msg = {'role': 'assistant'}
            new_msg['content'] = '\n'.join(text_parts) if text_parts else None
            if tool_calls:
                new_msg['tool_calls'] = tool_calls
            converted.append(new_msg)

        elif has_tool_result:
            other_parts = []
            for block in content:
                if not isinstance(block, dict):
                    continue
                if block.get('type') == 'tool_result':
                    rc = block.get('content', '')
                    if isinstance(rc, list):
                        rc = '\n'.join(
                            b.get('text', '') for b in rc
                            if isinstance(b, dict) and b.get('type') == 'text'
                        )
                    elif not isinstance(rc, str):
                        rc = str(rc)
                    converted.append({
                        'role': 'tool',
                        'tool_call_id': block.get('tool_use_id', ''),
                        'content': rc,
                    })
                else:
                    other_parts.append(block)
            if other_parts:
                converted.append({'role': role, 'content': other_parts})
        else:
            converted.append(msg)

    return converted


# ─── 非流式响应修复 ───────────────────────────────


def fix_response(data):
    """修复上游返回的非流式 OpenAI 响应"""
    if not isinstance(data, dict):
        return data

    for choice in (data.get('choices') or []):
        msg = choice.get('message') or {}

        # reasoningContent → reasoning_content
        if 'reasoningContent' in msg and 'reasoning_content' not in msg:
            msg['reasoning_content'] = msg.pop('reasoningContent')

        # <think> 标签 → reasoning_content
        content = msg.get('content') or ''
        if isinstance(content, str) and '<think>' in content and not msg.get('reasoning_content'):
            cleaned, reasoning = extract_from_text(content)
            if reasoning:
                msg['reasoning_content'] = reasoning
                msg['content'] = cleaned
                logger.info(f'提取 <think> 标签 → reasoning_content ({len(reasoning)} 字符)')

        # 旧版 function_call → 新版 tool_calls
        if 'function_call' in msg and 'tool_calls' not in msg:
            fc = msg.pop('function_call')
            msg['tool_calls'] = [{
                'id': gen_id('call_'),
                'type': 'function',
                'function': {
                    'name': fc.get('name', ''),
                    'arguments': fc.get('arguments', '{}'),
                },
            }]
            if choice.get('finish_reason') == 'function_call':
                choice['finish_reason'] = 'tool_calls'

        # 修复 tool_calls 字段
        _fix_tool_calls(msg, choice)

    return data


# ─── 流式 chunk 修复 ──────────────────────────────


def fix_stream_chunk(data):
    """修复上游返回的流式 OpenAI chunk"""
    if not isinstance(data, dict):
        return data

    for choice in (data.get('choices') or []):
        delta = choice.get('delta') or {}

        # reasoningContent → reasoning_content
        if 'reasoningContent' in delta and 'reasoning_content' not in delta:
            delta['reasoning_content'] = delta.pop('reasoningContent')

        # 旧版 function_call → tool_calls
        if 'function_call' in delta and 'tool_calls' not in delta:
            fc = delta.pop('function_call')
            tc = {'index': 0, 'type': 'function', 'function': {}}
            if 'name' in fc:
                tc['id'] = gen_id('call_')
                tc['function']['name'] = fc['name']
            if 'arguments' in fc:
                tc['function']['arguments'] = fc['arguments']
            delta['tool_calls'] = [tc]
            if choice.get('finish_reason') == 'function_call':
                choice['finish_reason'] = 'tool_calls'

        # 补全 tool_calls 字段
        for tc in (delta.get('tool_calls') or []):
            if 'index' not in tc:
                tc['index'] = 0
            func = tc.get('function') or {}
            if 'id' in tc or 'name' in func:
                if not tc.get('id'):
                    tc['id'] = gen_id('call_')
                if 'type' not in tc:
                    tc['type'] = 'function'

        if choice.get('finish_reason') == 'function_call':
            choice['finish_reason'] = 'tool_calls'

    return data


# ─── 内部辅助 ─────────────────────────────────────


def _fix_tool_calls(msg, choice):
    """修复消息中的 tool_calls 字段"""
    tool_calls = msg.get('tool_calls')
    if not tool_calls:
        return

    for i, tc in enumerate(tool_calls):
        if not tc.get('id'):
            tc['id'] = gen_id('call_')
        if 'index' not in tc:
            tc['index'] = i
        if tc.get('type') != 'function':
            tc['type'] = 'function'

        func = tc.get('function', {})
        args_raw = func.get('arguments', '{}')
        try:
            args = json.loads(args_raw) if isinstance(args_raw, str) else (args_raw or {})
        except json.JSONDecodeError:
            args = {}

        args = normalize_args(args)
        args = repair_str_replace_args(func.get('name', ''), args)
        func['arguments'] = json.dumps(args, ensure_ascii=False)

    if choice.get('finish_reason') not in ('tool_calls', 'function_call'):
        choice['finish_reason'] = 'tool_calls'