"""Authoring pipeline: Langflow export -> versioned definition -> LFX deploy."""

from __future__ import annotations

from sqlmodel import Session

from app.models import FlowDefinition, FlowVersion

from . import store
from .langflow_client import LangflowClient
from .lfx_client import LfxClient
from .schemas import FlowDefinitionCreate, FlowVersionCreate


async def import_from_langflow(
    session: Session,
    langflow: LangflowClient,
    lfx: LfxClient,
    langflow_flow_id: str,
    *,
    name: str | None = None,
    author: str = "",
    deploy: bool = True,
) -> tuple[FlowDefinition, FlowVersion]:
    """Export a flow from Langflow, store it as a new version, deploy to LFX.

    Definitions are matched by name (explicit `name` wins, else the exported
    name); every import creates a new immutable version.
    """
    export = await langflow.export_flow(langflow_flow_id)
    flow_name = name or export.get("name") or f"langflow-{langflow_flow_id}"
    langflow_json = {
        "id": export.get("id", langflow_flow_id),
        "name": flow_name,
        "description": export.get("description") or "",
        "endpoint_name": export.get("endpoint_name"),
        "data": export.get("data", {}),
        "tags": export.get("tags", []),
        "webhook": export.get("webhook", False),
        "is_component": export.get("is_component", False),
    }
    try:
        definition = next(
            d for d in store.list_definitions(session) if d.name == flow_name
        )
    except StopIteration:
        definition = store.create_definition(
            session, FlowDefinitionCreate(name=flow_name)
        )
    version = store.create_version(
        session,
        definition.id,
        FlowVersionCreate(langflow_json=langflow_json, author=author),
    )
    if deploy:
        uploaded = await lfx.upload_flow(
            version.langflow_json, flow_id=str(version.id), replace=True
        )
        version = store.mark_deployed(session, version, uploaded.id)
    return definition, version