from enum import Enum
from dataclasses import dataclass, field


class CallState(Enum):
  GREETING = "greeting"
  BILLING = "billing"
  SUPPORT = "support"
  SALES = "sales"
  TRANSFER_TO_HUMAN = "transfer_to_human"
  GOODBYE = "goodbye"


@dataclass
class CallContext:
  """Shared state passed between agents during a call."""
  caller_id: str
  caller_name: str | None = None
  account_number: str | None = None
  current_state: CallState = CallState.GREETING
  previous_states: list[CallState] = field(default_factory=list)
  intent_history: list[str] = field(default_factory=list)

  def transition(self, new_state: CallState, reason: str = ""):
      self.previous_states.append(self.current_state)
      self.current_state = new_state
      if reason:
          self.intent_history.append(reason)


# Valid transitions — prevents nonsensical jumps
VALID_TRANSITIONS: dict[CallState, set[CallState]] = {
  CallState.GREETING: {CallState.BILLING, CallState.SUPPORT, CallState.SALES, CallState.GOODBYE},
  CallState.BILLING: {CallState.TRANSFER_TO_HUMAN, CallState.SUPPORT, CallState.GOODBYE},
  CallState.SUPPORT: {CallState.TRANSFER_TO_HUMAN, CallState.BILLING, CallState.GOODBYE},
  CallState.SALES: {CallState.TRANSFER_TO_HUMAN, CallState.GOODBYE},
  CallState.TRANSFER_TO_HUMAN: {CallState.GOODBYE},
  CallState.GOODBYE: set(),
}

from livekit.agents import Agent, AgentSession, function_tool, RunContext


class GreetingAgent(Agent):
  def __init__(self):
      super().__init__(
          instructions="""You are the front desk of Acme Corp. Greet the caller warmly
          and determine which department they need from their natural speech.
          Use the route_to_department tool once you understand their intent.
          If the intent is ambiguous, ask ONE clarifying question — never present
          a menu of options. Keep the greeting under 15 seconds.""",
          tools=[route_to_department],
      )


class BillingAgent(Agent):
  def __init__(self):
      super().__init__(
          instructions="""You are a billing specialist at Acme Corp. Help callers with
          invoices, payment status, refunds, and account balance inquiries.
          Always verify the caller's account number before sharing details.
          If you cannot resolve the issue, use transfer_to_human to escalate.""",
          tools=[check_balance, process_refund, transfer_to_human],
      )


class SupportAgent(Agent):
  def __init__(self):
      super().__init__(
          instructions="""You are a technical support agent at Acme Corp. Help callers
          troubleshoot product issues. Walk callers through solutions step by step.
          If the issue requires hands-on intervention, escalate to a human agent.""",
          tools=[lookup_ticket, create_ticket, transfer_to_human],
      )


AGENT_MAP = {
  "billing": BillingAgent,
  "support": SupportAgent,
  "sales": SalesAgent,
}


@function_tool
async def route_to_department(context: RunContext, department: str, reason: str) -> str:
  """Route the caller to a specific department based on their stated need.

  Args:
      department: The department to route to (billing, support, sales).
      reason: Brief description of the caller's intent.
  """
  call_ctx: CallContext = context.userdata
  state_map = {
      "billing": CallState.BILLING,
      "support": CallState.SUPPORT,
      "sales": CallState.SALES,
  }
  target = state_map.get(department.lower())
  if target is None:
      return f"Unknown department '{department}'. Valid options: billing, support, sales."

  call_ctx.transition(target, reason)

  # Perform the actual agent handoff
  agent_cls = AGENT_MAP.get(department.lower())
  if agent_cls:
      context.session.update_agent(agent_cls())

  return f"Routing to {department}. Reason: {reason}"

import { Agent, AgentSession, RunContext } from "@livekit/agents";

class GreetingAgent extends Agent {
constructor() {
  super({
    instructions: `You are the front desk of Acme Corp. Greet the caller warmly
      and determine which department they need from their natural speech.
      Use the route_to_department tool once you understand their intent.
      If the intent is ambiguous, ask ONE clarifying question — never present
      a menu of options. Keep the greeting under 15 seconds.`,
    tools: [routeToDepartment],
  });
}
}

class BillingAgent extends Agent {
constructor() {
  super({
    instructions: `You are a billing specialist at Acme Corp. Help callers with
      invoices, payment status, refunds, and account balance inquiries.
      Always verify the caller's account number before sharing details.
      If you cannot resolve the issue, use transferToHuman to escalate.`,
    tools: [checkBalance, processRefund, transferToHuman],
  });
}
}

class SupportAgent extends Agent {
constructor() {
  super({
    instructions: `You are a technical support agent at Acme Corp. Help callers
      troubleshoot product issues. Walk callers through solutions step by step.
      If the issue requires hands-on intervention, escalate to a human agent.`,
    tools: [lookupTicket, createTicket, transferToHuman],
  });
}
}

from livekit.agents import AgentServer, AgentSession

server = AgentServer()

AGENT_MAP = {
  CallState.GREETING: GreetingAgent,
  CallState.BILLING: BillingAgent,
  CallState.SUPPORT: SupportAgent,
  CallState.SALES: SalesAgent,
}


@server.rtc_session
async def entrypoint(session: AgentSession):
  call_ctx = CallContext(caller_id=session.room.name)

  await session.start(
      agent=GreetingAgent(),
      room=session.room,
      userdata=call_ctx,
  )
  # The GreetingAgent's route_to_department tool calls
  # context.session.update_agent() to swap in the department
  # agent — the handoff happens automatically when the LLM
  # calls the routing tool.