LangBot/src/langbot/pkg/platform/adapters/lark/interaction.py

"""Lark card rendering and callback conversion for structured interactions."""

from __future__ import annotations

import json
import time
import typing
import uuid

from lark_oapi.api.cardkit.v1 import (
    Card,
    CreateCardRequest,
    CreateCardRequestBody,
    CreateCardResponse,
    UpdateCardRequest,
    UpdateCardRequestBody,
    UpdateCardResponse,
)
from lark_oapi.api.im.v1 import (
    CreateMessageRequest,
    CreateMessageRequestBody,
    CreateMessageResponse,
)

from langbot_plugin.api.entities.builtin.platform import events as platform_events


def interaction_delivery_capabilities() -> dict[str, typing.Any]:
    return {
        'field_types': ['text', 'textarea', 'number', 'select'],
        'action_styles': ['default', 'primary', 'danger'],
        'supports_updates': True,
        'max_fields': 1,
    }


def _callback_value(
    callback_token: str,
    reply_target: dict[str, typing.Any],
    **refs: typing.Any,
) -> dict[str, typing.Any]:
    return {
        'lbi': callback_token,
        't': str(reply_target.get('target_type') or ''),
        'ck': 1,
        **refs,
    }


def _field_form_elements(
    field: dict[str, typing.Any],
    callback_token: str,
    reply_target: dict[str, typing.Any],
) -> list[dict[str, typing.Any]] | None:
    field_type = str(field.get('type') or '')
    if field_type not in {'text', 'textarea', 'number', 'select'}:
        return None
    field_id = str(field.get('id') or '')
    if not field_id:
        return None
    component_name = 'lbi_field_0'
    label = str(field.get('label') or field_id)
    placeholder = str(
        field.get('placeholder')
        or ('Select an option / 请选择' if field_type == 'select' else 'Enter a value / 请输入')
    )
    required = bool(field.get('required'))
    if field_type == 'select':
        raw_options = field.get('options') if isinstance(field.get('options'), list) else []
        options = [
            {
                'text': {
                    'tag': 'plain_text',
                    'content': str(option.get('label') or option.get('value') or ''),
                },
                'value': str(option.get('value') or ''),
            }
            for option in raw_options
            if isinstance(option, dict) and option.get('value') not in (None, '')
        ]
        if not options:
            return None
        field_element: dict[str, typing.Any] = {
            'tag': 'select_static',
            'name': component_name,
            'label': {'tag': 'plain_text', 'content': label},
            'placeholder': {'tag': 'plain_text', 'content': placeholder},
            'options': options,
            'width': 'fill',
            'required': required,
        }
        default = field.get('default')
        if default not in (None, ''):
            field_element['initial_option'] = str(default)
    else:
        default = field.get('default')
        field_element = {
            'tag': 'input',
            'name': component_name,
            'label': {'tag': 'plain_text', 'content': label},
            'placeholder': {'tag': 'plain_text', 'content': placeholder},
            'default_value': '' if default is None else str(default),
            'width': 'fill',
            'required': required,
        }
        if field_type == 'textarea':
            field_element.update(
                {
                    'input_type': 'multiline_text',
                    'rows': 3,
                    'auto_resize': True,
                    'max_rows': 6,
                }
            )

    submit_value = _callback_value(
        callback_token,
        reply_target,
        fm={component_name: field_id},
        ft={field_id: field_type},
    )
    submit_button = {
        'tag': 'button',
        'name': 'lbi_submit',
        'text': {'tag': 'plain_text', 'content': 'Submit / 提交'},
        'type': 'primary',
        'width': 'fill',
        'form_action_type': 'submit',
        'behaviors': [{'type': 'callback', 'value': submit_value}],
    }
    form_elements: list[dict[str, typing.Any]] = [field_element, submit_button]
    if field_type == 'select':
        form_elements.insert(
            0,
            {
                'tag': 'markdown',
                'content': f'**{label}{"*" if required else ""}**',
            },
        )
    return [
        {
            'tag': 'form',
            'name': 'lbi_form',
            'direction': 'vertical',
            'vertical_spacing': '12px',
            'elements': form_elements,
        }
    ]


def _render_submitted_value(value: typing.Any) -> str:
    rendered = json.dumps(value, ensure_ascii=False) if isinstance(value, (dict, list)) else str(value)
    rendered = rendered.strip().replace('\n', '\n  ')
    return rendered if len(rendered) <= 2000 else rendered[:1997] + '...'


def _submission_display_values(
    request: dict[str, typing.Any],
    submission: dict[str, typing.Any],
) -> list[dict[str, str]]:
    display_values: list[dict[str, str]] = []
    values = submission.get('values') if isinstance(submission.get('values'), dict) else {}
    fields = request.get('fields') if isinstance(request.get('fields'), list) else []
    for field in fields:
        if not isinstance(field, dict):
            continue
        field_id = str(field.get('id') or '')
        if field_id and field_id in values:
            display_value = {
                'label': str(field.get('label') or field_id),
                'value': _render_submitted_value(values[field_id]),
            }
            description = str(request.get('description') or '').strip()
            if description:
                display_value['description'] = description
            display_values.append(display_value)

    action_id = submission.get('action_id')
    if action_id:
        actions = request.get('actions') if isinstance(request.get('actions'), list) else []
        action_label = next(
            (
                str(action.get('label') or action_id)
                for action in actions
                if isinstance(action, dict) and str(action.get('id') or '') == str(action_id)
            ),
            str(action_id),
        )
        display_values.append({'label': 'Action', 'value': action_label})
    return display_values


def _stored_submitted_values(value: typing.Any) -> list[dict[str, str]]:
    if not isinstance(value, list):
        return []
    stored_values = [
        {
            'label': str(item['label'])[:200],
            'value': str(item['value'])[:2000],
            **({'description': str(item['description'])[:4000]} if item.get('description') is not None else {}),
        }
        for item in value[:50]
        if isinstance(item, dict) and item.get('label') is not None and item.get('value') is not None
    ]
    return stored_values


def _submitted_value_elements(values: list[dict[str, str]]) -> list[dict[str, typing.Any]]:
    elements: list[dict[str, typing.Any]] = []
    for item in values:
        lines = []
        description = str(item.get('description') or '').strip()
        if description:
            lines.append(description)
        lines.append(f'✅ {item["label"]}：{item["value"]}')
        elements.append({'tag': 'markdown', 'content': '\n'.join(lines)})
    return elements


def build_interaction_card(
    request: dict[str, typing.Any],
    callback_token: str,
    reply_target: dict[str, typing.Any],
    submitted_values: list[dict[str, str]] | None = None,
) -> dict[str, typing.Any] | None:
    """Build the Lark subset that maps to a single atomic submission."""
    fields = request.get('fields') if isinstance(request.get('fields'), list) else []
    actions = request.get('actions') if isinstance(request.get('actions'), list) else []
    buttons: list[dict[str, typing.Any]] = []
    field_elements: list[dict[str, typing.Any]] | None = None

    if actions and not fields:
        for index, action in enumerate(actions):
            if not isinstance(action, dict):
                continue
            style = str(action.get('style') or 'default')
            buttons.append(
                {
                    'tag': 'button',
                    'text': {
                        'tag': 'plain_text',
                        'content': str(action.get('label') or action.get('id') or index + 1),
                    },
                    'type': 'primary' if style == 'primary' else 'danger' if style == 'danger' else 'default',
                    'behaviors': [
                        {
                            'type': 'callback',
                            'value': _callback_value(callback_token, reply_target, a=index),
                        }
                    ],
                }
            )
    elif len(fields) == 1 and not actions and isinstance(fields[0], dict):
        field = fields[0]
        field_elements = _field_form_elements(field, callback_token, reply_target)
        if field_elements is None:
            return None
    else:
        return None

    if not buttons and not field_elements:
        return None
    elements: list[dict[str, typing.Any]] = []
    elements.extend(_submitted_value_elements(submitted_values or []))
    description = str(request.get('description') or '').strip()
    if description:
        elements.append({'tag': 'markdown', 'content': description})
    if field_elements:
        elements.extend(field_elements)
    else:
        elements.append(
            {
                'tag': 'column_set',
                'horizontal_spacing': '8px',
                'columns': [
                    {
                        'tag': 'column',
                        'width': 'weighted',
                        'weight': 1,
                        'elements': [button],
                    }
                    for button in buttons
                ],
            }
        )
    return {
        'schema': '2.0',
        'config': {'update_multi': True},
        'header': {
            'title': {'tag': 'plain_text', 'content': str(request.get('title') or '')},
        },
        'body': {'direction': 'vertical', 'elements': elements},
    }


def build_submitted_card(
    request: dict[str, typing.Any],
    submission: dict[str, typing.Any],
    submitted_values: list[dict[str, str]] | None = None,
) -> dict[str, typing.Any]:
    """Render a read-only snapshot after a user submits an interaction."""
    elements: list[dict[str, typing.Any]] = []
    all_submitted_values = [
        *(submitted_values or []),
        *_submission_display_values(request, submission),
    ]
    elements.extend(_submitted_value_elements(all_submitted_values))
    return {
        'schema': '2.0',
        'config': {'update_multi': True},
        'header': {'title': {'tag': 'plain_text', 'content': str(request.get('title') or '')}},
        'body': {'direction': 'vertical', 'elements': elements},
    }


async def _update_interaction_card(
    adapter: typing.Any,
    update_target: dict[str, typing.Any],
    card: dict[str, typing.Any],
    submitted_values: list[dict[str, str]] | None = None,
) -> dict[str, typing.Any]:
    message_id = str(update_target.get('message_id') or '')
    card_id = str(update_target.get('card_id') or '')
    if not message_id or not card_id or update_target.get('rich') is not True:
        raise ValueError('Lark interaction update requires a CardKit target')
    persisted_sequence = int(update_target.get('sequence') or 0)
    current_sequence = int(adapter.card_sequence_dict.get(card_id, persisted_sequence))
    sequence = max(persisted_sequence, current_sequence) + 1
    request = (
        UpdateCardRequest.builder()
        .card_id(card_id)
        .request_body(
            UpdateCardRequestBody.builder()
            .sequence(sequence)
            .uuid(str(uuid.uuid4()))
            .card(Card.builder().type('card_json').data(json.dumps(card, ensure_ascii=False)).build())
            .build()
        )
        .build()
    )
    response: UpdateCardResponse = await adapter.api_client.cardkit.v1.card.aupdate(request)
    if not response.success():
        raise RuntimeError(f'Lark CardKit interaction update failed: {response.code} {response.msg}')
    adapter.card_sequence_dict[card_id] = sequence
    result = {
        'ok': True,
        'message_id': message_id,
        'card_id': card_id,
        'sequence': sequence,
        'rich': True,
        'updated': True,
    }
    if submitted_values:
        result['submitted_values'] = submitted_values
    return result


async def send_interaction(adapter: typing.Any, params: dict[str, typing.Any]) -> dict[str, typing.Any]:
    request = params.get('request')
    reply_target = params.get('reply_target')
    callback_token = str(params.get('callback_token') or '')
    if not isinstance(request, dict) or not isinstance(reply_target, dict) or not callback_token:
        raise ValueError('interaction.request requires request, reply_target, and callback_token')

    update_target = params.get('update_target')
    submitted_values = _stored_submitted_values(
        update_target.get('submitted_values') if isinstance(update_target, dict) else None
    )
    card = build_interaction_card(request, callback_token, reply_target, submitted_values)
    if card is None:
        fallback = str(request.get('fallback_text') or '')
        result = await adapter.send_message(
            str(reply_target.get('target_type') or ''),
            str(reply_target.get('target_id') or ''),
            adapter._plain_message(fallback),
        )
        return {'ok': True, 'message_id': result.message_id, 'rich': False}

    if isinstance(update_target, dict):
        return await _update_interaction_card(adapter, update_target, card, submitted_values)

    target_type = str(reply_target.get('target_type') or '')
    target_id = str(reply_target.get('target_id') or '')
    if target_type not in {'group', 'person'} or not target_id:
        raise ValueError('interaction.request has an invalid reply target')
    card_request = (
        CreateCardRequest.builder()
        .request_body(
            CreateCardRequestBody.builder().type('card_json').data(json.dumps(card, ensure_ascii=False)).build()
        )
        .build()
    )
    card_response: CreateCardResponse = await adapter.api_client.cardkit.v1.card.acreate(card_request)
    if not card_response.success():
        raise RuntimeError(f'Lark CardKit interaction create failed: {card_response.code} {card_response.msg}')
    card_id = str(getattr(card_response.data, 'card_id', '') or '')
    if not card_id:
        raise RuntimeError('Lark CardKit interaction create returned no card_id')

    message_request = (
        CreateMessageRequest.builder()
        .receive_id_type('chat_id' if target_type == 'group' else 'open_id')
        .request_body(
            CreateMessageRequestBody.builder()
            .receive_id(target_id)
            .content(json.dumps({'type': 'card', 'data': {'card_id': card_id}}, ensure_ascii=False))
            .msg_type('interactive')
            .uuid(str(uuid.uuid4()))
            .build()
        )
        .build()
    )
    response: CreateMessageResponse = await adapter.api_client.im.v1.message.acreate(message_request)
    if not response.success():
        raise RuntimeError(f'Lark interaction send failed: {response.code} {response.msg}')
    adapter.card_sequence_dict[card_id] = 0
    return {
        'ok': True,
        'message_id': getattr(response.data, 'message_id', ''),
        'card_id': card_id,
        'sequence': 0,
        'rich': True,
    }


async def acknowledge_interaction(adapter: typing.Any, params: dict[str, typing.Any]) -> dict[str, typing.Any]:
    request = params.get('request')
    submission = params.get('submission')
    update_target = params.get('update_target')
    if not isinstance(request, dict) or not isinstance(submission, dict) or not isinstance(update_target, dict):
        raise ValueError('interaction.acknowledge requires request, submission, and update_target')
    submitted_values = [
        *_stored_submitted_values(update_target.get('submitted_values')),
        *_submission_display_values(request, submission),
    ]
    return await _update_interaction_card(
        adapter,
        update_target,
        build_submitted_card(request, submission, _stored_submitted_values(update_target.get('submitted_values'))),
        submitted_values,
    )


def _mapping(value: typing.Any) -> dict[str, typing.Any]:
    if isinstance(value, dict):
        return value
    if isinstance(value, str):
        try:
            parsed = json.loads(value)
        except json.JSONDecodeError:
            return {}
        return parsed if isinstance(parsed, dict) else {}
    return {}


def _action_attr(action: typing.Any, name: str) -> typing.Any:
    return action.get(name) if isinstance(action, dict) else getattr(action, name, None)


def _coerce_field_value(value: typing.Any, field_type: str) -> typing.Any:
    if isinstance(value, dict):
        value = value.get('value') if value.get('value') is not None else value.get('option')
    if field_type != 'number' or isinstance(value, (int, float)) and not isinstance(value, bool):
        return value
    text = str(value).strip()
    try:
        return int(text)
    except ValueError:
        try:
            return float(text)
        except ValueError:
            return value


def _form_submission_values(action: typing.Any, payload: dict[str, typing.Any]) -> dict[str, typing.Any]:
    field_map = payload.get('fm') if isinstance(payload.get('fm'), dict) else {}
    field_types = payload.get('ft') if isinstance(payload.get('ft'), dict) else {}
    if not field_map:
        return {}
    form_value = _mapping(_action_attr(action, 'form_value'))
    if not form_value:
        for key in ('form_value', 'formValue', 'form_values', 'formValues'):
            form_value = _mapping(payload.get(key))
            if form_value:
                break
    if not form_value:
        action_name = _action_attr(action, 'name')
        input_value = _action_attr(action, 'input_value')
        option_value = _action_attr(action, 'option')
        if action_name and input_value not in (None, ''):
            form_value = {str(action_name): input_value}
        elif action_name and option_value not in (None, ''):
            form_value = {str(action_name): option_value}
    values: dict[str, typing.Any] = {}
    for component_name, value in form_value.items():
        field_id = field_map.get(component_name)
        if field_id and value not in (None, ''):
            values[str(field_id)] = _coerce_field_value(value, str(field_types.get(str(field_id)) or ''))
    return values


def _event_from_parts(
    *,
    raw: typing.Any,
    action: typing.Any,
    actor_id: typing.Any,
    chat_id: typing.Any,
    message_id: typing.Any,
) -> platform_events.PlatformSpecificEvent | None:
    payload = _mapping(_action_attr(action, 'value'))
    callback_token = str(payload.get('lbi') or '')
    if not callback_token:
        return None
    target_type = str(payload.get('t') or '')
    target_id = str(chat_id or '') if target_type == 'group' else str(actor_id or '')
    data: dict[str, typing.Any] = {
        'callback_token': callback_token,
        'actor_id': str(actor_id or ''),
        'target_type': target_type,
        'target_id': target_id,
        'display_text': 'submitted',
    }
    if payload.get('ck') == 1:
        data['cardkit'] = True
    if message_id:
        data['message_id'] = str(message_id)
    if payload.get('a') is not None:
        data['action_ref'] = payload['a']
    if payload.get('f') is not None or payload.get('o') is not None:
        data['field_ref'] = payload.get('f')
        data['option_ref'] = payload.get('o')
    if payload.get('fm'):
        data['values'] = _form_submission_values(action, payload)
    return platform_events.PlatformSpecificEvent(
        type='platform.specific',
        adapter_name='lark-omni',
        action='interaction.submitted',
        data=data,
        timestamp=time.time(),
        source_platform_object=raw,
    )


def interaction_event_from_callback(event: typing.Any) -> platform_events.PlatformSpecificEvent | None:
    action = getattr(getattr(event, 'event', None), 'action', None)
    operator = getattr(getattr(event, 'event', None), 'operator', None)
    context = getattr(getattr(event, 'event', None), 'context', None)
    return _event_from_parts(
        raw=event,
        action=action,
        actor_id=getattr(operator, 'open_id', None) or getattr(operator, 'user_id', None),
        chat_id=getattr(context, 'open_chat_id', None),
        message_id=getattr(context, 'open_message_id', None),
    )


def interaction_event_from_webhook(data: dict[str, typing.Any]) -> platform_events.PlatformSpecificEvent | None:
    event = data.get('event') if isinstance(data.get('event'), dict) else {}
    action = event.get('action') if isinstance(event.get('action'), dict) else {}
    operator = event.get('operator') if isinstance(event.get('operator'), dict) else {}
    context = event.get('context') if isinstance(event.get('context'), dict) else {}
    return _event_from_parts(
        raw=data,
        action=action,
        actor_id=operator.get('open_id') or operator.get('user_id'),
        chat_id=context.get('open_chat_id'),
        message_id=context.get('open_message_id'),
    )