"""Responses API 适配

Cursor 对 GPT/Claude-Opus 等模型使用 /v1/responses 格式。
本模块将 Responses 格式与 Chat Completions 格式互相转换：
  请求: Responses → CC
  响应: CC → Responses（非流式 + 流式）
  流式: 支持从 CC chunks 或 Anthropic SSE 事件直接转换
"""

import json
import logging

from utils.http import gen_id

logger = logging.getLogger(__name__)


# ═══════════════════════════════════════════════════════════
#  请求转换: Responses → CC
# ═══════════════════════════════════════════════════════════


def responses_to_cc(payload):
    """将 /v1/responses 请求转换为 /v1/chat/completions 格式"""
    messages = []

    if payload.get('instructions'):
        messages.append({'role': 'system', 'content': payload['instructions']})

    input_data = payload.get('input', [])
    if isinstance(input_data, str):
        messages.append({'role': 'user', 'content': input_data})
    elif isinstance(input_data, list):
        _convert_input_items(input_data, messages)

    result = {
        'model': payload.get('model', ''),
        'messages': messages,
        'stream': payload.get('stream', False),
    }

    if 'tools' in payload:
        result['tools'] = _convert_tools(payload['tools'])
    for key in ('temperature', 'top_p'):
        if key in payload:
            result[key] = payload[key]
    if 'max_output_tokens' in payload:
        result['max_tokens'] = payload['max_output_tokens']
    if 'tool_choice' in payload:
        result['tool_choice'] = payload['tool_choice']

    return result


# ═══════════════════════════════════════════════════════════
#  非流式响应转换: CC → Responses
# ═══════════════════════════════════════════════════════════


def cc_to_responses(cc_resp, model=''):
    """将 CC 响应转换为 Responses 格式"""
    choice = (cc_resp.get('choices') or [{}])[0]
    msg = choice.get('message') or {}
    finish = choice.get('finish_reason', 'stop')

    output = []

    if msg.get('reasoning_content'):
        output.append({
            'type': 'reasoning',
            'id': gen_id('rs_'),
            'summary': [{'type': 'summary_text', 'text': msg['reasoning_content']}],
        })

    if msg.get('content'):
        output.append({
            'type': 'message',
            'id': gen_id('msg_'),
            'status': 'completed',
            'role': 'assistant',
            'content': [{'type': 'output_text', 'text': msg['content']}],
        })

    for tc in (msg.get('tool_calls') or []):
        func = tc.get('function') or {}
        output.append({
            'type': 'function_call',
            'id': gen_id('fc_'),
            'status': 'completed',
            'call_id': tc.get('id', gen_id('call_')),
            'name': func.get('name', ''),
            'arguments': func.get('arguments', '{}'),
        })

    usage = cc_resp.get('usage', {})
    return {
        'id': cc_resp.get('id', gen_id('resp_')),
        'object': 'response',
        'status': 'incomplete' if finish == 'length' else 'completed',
        'model': model or cc_resp.get('model', ''),
        'output': output,
        'usage': {
            'input_tokens': usage.get('prompt_tokens', 0),
            'output_tokens': usage.get('completion_tokens', 0),
            'total_tokens': usage.get('total_tokens', 0),
        },
    }


# ═══════════════════════════════════════════════════════════
#  流式转换器: CC chunks / Anthropic SSE → Responses SSE
# ═══════════════════════════════════════════════════════════


class ResponsesStreamConverter:
    """有状态转换器：将 CC 流式 chunk 或 Anthropic SSE 事件转为 Responses SSE 事件"""

    def __init__(self, response_id=None, model=''):
        self.resp_id = response_id or gen_id('resp_')
        self.model = model

        # 思考内容缓冲
        self._rs_buf = ''
        self._rs_started = False
        self._rs_closed = False
        self._rs_id = gen_id('rs_')

        # 文本内容缓冲
        self._text_buf = ''
        self._text_started = False
        self._text_closed = False
        self._msg_id = gen_id('msg_')

        # 工具调用缓冲 {index: {name, args, call_id, fc_id}}
        self._tools = {}
        self._output_items = []
        self._finished = False
        self._input_tokens = 0

    # ─── 公开接口 ─────────────────────────────────

    def start_events(self):
        """生成流开始事件"""
        return [self._sse('response.created', {
            'id': self.resp_id, 'object': 'response',
            'status': 'in_progress', 'model': self.model, 'output': [],
        })]

    def process_cc_chunk(self, chunk):
        """处理 CC 格式的流式 chunk，返回 Responses SSE 事件列表"""
        events = []
        for choice in (chunk.get('choices') or []):
            delta = choice.get('delta') or {}
            finish = choice.get('finish_reason')

            if delta.get('reasoning_content'):
                events.extend(self._on_reasoning(delta['reasoning_content']))
            if delta.get('content') is not None and delta['content'] != '':
                events.extend(self._on_text(delta['content']))
            for tc in (delta.get('tool_calls') or []):
                events.extend(self._on_tool_call(tc))
            if finish and not self._finished:
                self._finished = True
                events.extend(self._do_finish(finish, chunk.get('usage')))

        return events

    def process_anthropic_event(self, event_type, event_data):
        """直接处理 Anthropic SSE 事件（跳过 CC 中间转换，更高效）"""
        events = []

        if event_type == 'message_start':
            usage = event_data.get('message', {}).get('usage', {})
            self._input_tokens = usage.get('input_tokens', 0)

        elif event_type == 'content_block_start':
            block = event_data.get('content_block', {})
            btype = block.get('type', '')
            if btype == 'thinking' and not self._rs_started:
                self._rs_started = True
                events.append(self._sse('response.output_item.added', {
                    'type': 'reasoning', 'id': self._rs_id, 'summary': [],
                }))
            elif btype == 'text':
                events.extend(self._ensure_text_started())
            elif btype == 'tool_use':
                events.extend(self._start_tool_from_block(block))

        elif event_type == 'content_block_delta':
            delta = event_data.get('delta', {})
            dtype = delta.get('type', '')
            if dtype == 'thinking_delta' and delta.get('thinking'):
                self._rs_buf += delta['thinking']
                events.append(self._sse('response.reasoning_summary_text.delta', {
                    'type': 'summary_text', 'delta': delta['thinking'],
                }))
            elif dtype == 'text_delta' and delta.get('text'):
                self._text_buf += delta['text']
                events.append(self._sse('response.output_text.delta', {
                    'type': 'output_text', 'delta': delta['text'],
                }))
            elif dtype == 'input_json_delta' and delta.get('partial_json') and self._tools:
                idx = max(self._tools.keys())
                self._tools[idx]['args'] += delta['partial_json']
                events.append(self._sse('response.function_call_arguments.delta', {
                    'type': 'function_call', 'delta': delta['partial_json'],
                }))

        elif event_type == 'message_delta':
            delta = event_data.get('delta', {})
            stop = delta.get('stop_reason', 'end_turn')
            usage = event_data.get('usage', {})
            finish = {'tool_use': 'tool_calls', 'max_tokens': 'length'}.get(stop, 'stop')
            if not self._finished:
                self._finished = True
                u = {
                    'input_tokens': self._input_tokens,
                    'output_tokens': usage.get('output_tokens', 0),
                    'total_tokens': self._input_tokens + usage.get('output_tokens', 0),
                }
                events.extend(self._do_finish(finish, u))

        return events

    def finalize(self):
        """流结束时补发未关闭的事件"""
        if self._finished:
            return []
        self._finished = True
        return self._do_finish('stop', None)

    # ─── 内部事件处理 ─────────────────────────────

    def _on_reasoning(self, text):
        """处理思考内容 delta"""
        events = []
        if not self._rs_started:
            self._rs_started = True
            events.append(self._sse('response.output_item.added', {
                'type': 'reasoning', 'id': self._rs_id, 'summary': [],
            }))
        self._rs_buf += text
        events.append(self._sse('response.reasoning_summary_text.delta', {
            'type': 'summary_text', 'delta': text,
        }))
        return events

    def _on_text(self, text):
        """处理文本内容 delta"""
        events = self._ensure_text_started()
        self._text_buf += text
        events.append(self._sse('response.output_text.delta', {
            'type': 'output_text', 'delta': text,
        }))
        return events

    def _on_tool_call(self, tc):
        """处理工具调用 delta"""
        events = []
        idx = tc.get('index', 0)
        func = tc.get('function') or {}

        if idx not in self._tools:
            if self._rs_started and not self._rs_closed:
                events.extend(self._close_reasoning())
            if self._text_started and not self._text_closed:
                events.extend(self._close_text())
            call_id = tc.get('id', gen_id('call_'))
            name = func.get('name', '')
            fc_id = gen_id('fc_')
            self._tools[idx] = {'name': name, 'args': '', 'call_id': call_id, 'fc_id': fc_id}
            events.append(self._sse('response.output_item.added', {
                'type': 'function_call', 'id': fc_id,
                'status': 'in_progress', 'call_id': call_id,
                'name': name, 'arguments': '',
            }))

        if func.get('name'):
            self._tools[idx]['name'] = func['name']
        if func.get('arguments', ''):
            self._tools[idx]['args'] += func['arguments']
            events.append(self._sse('response.function_call_arguments.delta', {
                'type': 'function_call', 'delta': func['arguments'],
            }))
        return events

    def _ensure_text_started(self):
        """确保文本输出项已开始"""
        events = []
        if self._rs_started and not self._rs_closed:
            events.extend(self._close_reasoning())
        if not self._text_started:
            self._text_started = True
            events.append(self._sse('response.output_item.added', {
                'type': 'message', 'id': self._msg_id,
                'status': 'in_progress', 'role': 'assistant', 'content': [],
            }))
            events.append(self._sse('response.content_part.added', {
                'type': 'output_text', 'text': '',
            }))
        return events

    def _start_tool_from_block(self, block):
        """从 Anthropic tool_use block 开始新的工具调用"""
        events = []
        if self._rs_started and not self._rs_closed:
            events.extend(self._close_reasoning())
        if self._text_started and not self._text_closed:
            events.extend(self._close_text())
        idx = len(self._tools)
        tool_id = block.get('id', gen_id('toolu_'))
        name = block.get('name', '')
        fc_id = gen_id('fc_')
        self._tools[idx] = {'name': name, 'args': '', 'call_id': tool_id, 'fc_id': fc_id}
        events.append(self._sse('response.output_item.added', {
            'type': 'function_call', 'id': fc_id,
            'status': 'in_progress', 'call_id': tool_id,
            'name': name, 'arguments': '',
        }))
        return events

    # ─── 关闭/结束事件 ────────────────────────────

    def _close_reasoning(self):
        if self._rs_closed:
            return []
        self._rs_closed = True
        rs = {
            'type': 'reasoning', 'id': self._rs_id,
            'summary': [{'type': 'summary_text', 'text': self._rs_buf}],
        }
        self._output_items.append(rs)
        return [
            self._sse('response.reasoning_summary_text.done', {
                'type': 'summary_text', 'text': self._rs_buf,
            }),
            self._sse('response.output_item.done', rs),
        ]

    def _close_text(self):
        if self._text_closed:
            return []
        self._text_closed = True
        msg = {
            'type': 'message', 'id': self._msg_id,
            'status': 'completed', 'role': 'assistant',
            'content': [{'type': 'output_text', 'text': self._text_buf}],
        }
        self._output_items.append(msg)
        return [
            self._sse('response.output_text.done', {'type': 'output_text', 'text': self._text_buf}),
            self._sse('response.output_item.done', msg),
        ]

    def _do_finish(self, finish_reason, usage):
        """生成流结束的所有关闭事件"""
        events = []
        if self._rs_started and not self._rs_closed:
            events.extend(self._close_reasoning())
        if self._text_started and not self._text_closed:
            events.extend(self._close_text())

        for idx in sorted(self._tools.keys()):
            buf = self._tools[idx]
            events.append(self._sse('response.function_call_arguments.done', {
                'type': 'function_call', 'arguments': buf['args'],
            }))
            fc = {
                'type': 'function_call', 'id': buf['fc_id'],
                'status': 'completed', 'call_id': buf['call_id'],
                'name': buf['name'], 'arguments': buf['args'],
            }
            events.append(self._sse('response.output_item.done', fc))
            self._output_items.append(fc)

        usage_data = usage if isinstance(usage, dict) else {}
        events.append(self._sse('response.completed', {
            'id': self.resp_id, 'object': 'response',
            'status': 'incomplete' if finish_reason == 'length' else 'completed',
            'model': self.model, 'output': self._output_items, 'usage': usage_data,
        }))
        return events

    def _sse(self, event_type, data):
        """构建 SSE 事件字符串"""
        return f'event: {event_type}\ndata: {json.dumps(data, ensure_ascii=False)}\n\n'


# ═══════════════════════════════════════════════════════════
#  内部辅助函数
# ═══════════════════════════════════════════════════════════


def _convert_input_items(items, messages):
    """将 Responses input 数组转换为 CC messages"""
    i = 0
    while i < len(items):
        item = items[i]

        if isinstance(item, str):
            messages.append({'role': 'user', 'content': item})
            i += 1
            continue

        if not isinstance(item, dict):
            i += 1
            continue

        item_type = item.get('type', '')
        role = item.get('role', '')

        # 简单角色消息（无 type 字段）
        if role and not item_type:
            content = item.get('content', '')
            if isinstance(content, list):
                content = _extract_text(content)
            messages.append({'role': role, 'content': content or ''})
            i += 1
            continue

        # Responses message 对象
        if item_type == 'message' or (role and not item_type):
            role = item.get('role', 'assistant')
            content = _extract_text(item.get('content', []))
            msg = {'role': role, 'content': content or ''}
            if role == 'assistant':
                tool_calls, consumed = _collect_function_calls(items, i + 1)
                if tool_calls:
                    msg['tool_calls'] = tool_calls
                    if not msg['content']:
                        msg['content'] = None
                    messages.append(msg)
                    i += 1 + consumed
                    continue
            messages.append(msg)
            i += 1
            continue

        # function_call（工具调用）
        if item_type == 'function_call':
            tc = {
                'id': item.get('call_id') or gen_id('call_'),
                'type': 'function',
                'function': {
                    'name': item.get('name', ''),
                    'arguments': item.get('arguments', '{}'),
                },
            }
            if messages and messages[-1]['role'] == 'assistant':
                messages[-1].setdefault('tool_calls', []).append(tc)
                if not messages[-1].get('content'):
                    messages[-1]['content'] = None
            else:
                messages.append({'role': 'assistant', 'content': None, 'tool_calls': [tc]})
            i += 1
            continue

        # function_call_output（工具结果）
        if item_type == 'function_call_output':
            output = item.get('output', '')
            if not isinstance(output, str):
                output = json.dumps(output, ensure_ascii=False)
            messages.append({
                'role': 'tool',
                'tool_call_id': item.get('call_id', ''),
                'content': output,
            })
            i += 1
            continue

        if role:
            messages.append({'role': role, 'content': str(item.get('content', ''))})
        i += 1


def _collect_function_calls(items, start):
    """收集紧随 assistant message 之后的连续 function_call 项"""
    tool_calls = []
    j = start
    while j < len(items):
        nxt = items[j]
        if isinstance(nxt, dict) and nxt.get('type') == 'function_call':
            tool_calls.append({
                'id': nxt.get('call_id') or gen_id('call_'),
                'type': 'function',
                'function': {
                    'name': nxt.get('name', ''),
                    'arguments': nxt.get('arguments', '{}'),
                },
            })
            j += 1
        else:
            break
    return tool_calls, j - start


def _extract_text(content):
    """从 content 中提取纯文本"""
    if isinstance(content, str):
        return content
    if not isinstance(content, list):
        return str(content) if content else ''
    texts = []
    for part in content:
        if isinstance(part, str):
            texts.append(part)
        elif isinstance(part, dict):
            t = part.get('type', '')
            if t in ('output_text', 'input_text', 'text'):
                texts.append(part.get('text', ''))
            elif t == 'refusal':
                texts.append(part.get('refusal', ''))
    return '\n'.join(texts) if texts else ''


def _convert_tools(tools):
    """将 Responses tools 转为 CC tools 格式"""
    result = []
    for t in tools:
        if t.get('type') != 'function':
            continue
        if 'function' in t:
            result.append(t)
        else:
            result.append({
                'type': 'function',
                'function': {
                    'name': t.get('name', ''),
                    'description': t.get('description', ''),
                    'parameters': t.get('parameters', {'type': 'object', 'properties': {}}),
                },
            })
    return result