"""Run the same routing policy through LangGraph and Microsoft Agent Framework."""
import asyncio
from typing import Never, TypedDict
from agent_framework import WorkflowBuilder, WorkflowContext, executor
from langchain_core.runnables import RunnableLambda
from langgraph.graph import END, START, StateGraph
from routing import destination, make_scorer


class Ticket(TypedDict):
    text: str
    billing_form: bool


class State(Ticket, total=False):
    queue: str


def build_workflows(score):
    def classify(ticket):
        if ticket["billing_form"]:
            return "billing"
        try:
            return destination(score(ticket["text"]), .90)
        except Exception:
            return "review"

    route = RunnableLambda(classify)
    graph = StateGraph(State)
    graph.add_node("route", lambda state: {"queue": route.invoke(state)})
    graph.add_edge(START, "route")
    graph.add_edge("route", END)

    @executor(id="route")
    async def route_ticket(ticket: dict, ctx: WorkflowContext[Never, str]) -> None:
        queue = await asyncio.to_thread(classify, ticket)
        await ctx.yield_output(queue)

    workflow = WorkflowBuilder(start_executor=route_ticket, output_from=[route_ticket]).build()
    return graph.compile(), workflow


async def main():
    import argparse
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--provider", choices=["replay", "openai", "gemini", "foundry"], default="replay")
    provider = parser.parse_args().provider
    score = (lambda text: .96) if provider == "replay" else make_scorer(provider)
    graph, workflow = build_workflows(score)
    ticket = {"text": "You charged my card twice.", "billing_form": False}
    print("LangGraph:", graph.invoke(ticket)["queue"])
    print("Agent Framework:", (await workflow.run(ticket)).get_outputs()[0])


if __name__ == "__main__":
    asyncio.run(main())
