"""Adapt LangChain messages for Responses-compatible model families."""

from collections.abc import Sequence
from typing import Any

from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage


_USER_ROLE_MODELS = {"mimo-v2.6-pro", "mimo-v2.6-flash"}


def adapt_responses_messages(
    messages: Sequence[BaseMessage], model_name: str | None
) -> Sequence[BaseMessage]:
    """Send selected models user-role instructions without changing stored history.

    Full Artemis requests to GPT models can fail with system-role input. The
    equivalent user-role request works with GPT and the two tested Mimo models.
    Other models keep their existing message roles.
    """
    if not model_name:
        return messages
    model = model_name.strip().lower()
    if not (model.startswith("gpt") or model in _USER_ROLE_MODELS):
        return messages
    if not any(isinstance(message, SystemMessage) for message in messages):
        return messages

    adapted: list[BaseMessage] = []
    pending_blocks: list[dict[str, Any]] = []
    for message in messages:
        if isinstance(message, SystemMessage):
            content = message.content
            if isinstance(content, str):
                pending_blocks.append({"type": "text", "text": content})
            else:
                pending_blocks.extend(
                    {"type": "text", "text": block} if isinstance(block, str) else block
                    for block in content
                )
            continue

        if pending_blocks:
            if isinstance(message, HumanMessage):
                content = message.content
                blocks = (
                    [{"type": "text", "text": content}]
                    if isinstance(content, str)
                    else list(content)
                )
                adapted.append(
                    message.model_copy(
                        update={
                            "content": [
                                *pending_blocks,
                                *blocks,
                            ]
                        }
                    )
                )
                pending_blocks = []
                continue
            adapted.append(HumanMessage(content=pending_blocks))
            pending_blocks = []
        adapted.append(message)

    if pending_blocks:
        adapted.append(HumanMessage(content=pending_blocks))
    return adapted