type SessionStatus = "disconnected" | "connecting" | "connected";
type AgentStatus = "idle" | "listening" | "speaking" | "thinking";

import { tool } from "@classytic/realtime-agents";
import { z } from "zod";

const weatherTool = tool({
  name: "get_weather",
  description: "Get current weather for a city",
  parameters: z.object({ city: z.string() }),
  execute: async ({ city }) => {
    const res = await fetch(`/api/weather?city=${city}`);
    return res.json();
  },
});

import { getToolContext } from "@classytic/realtime-agents";

const captureImageTool = tool({
  name: "capture_image",
  description: "Capture and analyze the current camera frame",
  parameters: z.object({}),
  execute: async () => {
    const ctx = getToolContext();

    // Access session context passed during connect
    const interviewId = ctx.sessionContext.interviewId;

    // Send an image through the active session
    ctx.sendImage(dataUrl, { triggerResponse: true });

    // Access the raw provider session (escape hatch)
    const rawSession = ctx.providerSession;

    return { captured: true };
  },
});

await session.connect({
  // Required: returns API key or client secret
  getCredentials: async () => "...",

  // Required: agent configuration
  agent: {
    name: "assistant",
    instructions: "You are a helpful assistant.",
    tools: [weatherTool],
    voice: "coral",
      providerOptions: openAIAgentOptions({
        prompt: {
          promptId: "pmpt_123",
          variables: { locale: "en-IN" },
        },
      }),
  },

  // Optional: HTML audio element for playback (WebRTC)
  audioElement: document.getElementById("audio"),

  // Optional: session context accessible via getToolContext()
  context: { interviewId: "123", candidateName: "Alice" },

  // Optional: pass an existing MediaStream (e.g. with video tracks)
  mediaStream: cameraStream,

  // Optional: pre-seed conversation history
  history: [
    { role: "user", text: "My name is Alice." },
    { role: "assistant", text: "Nice to meet you, Alice!" },
  ],

  // Optional: provider-native session options
  providerOptions: openAISessionOptions({
    workflowName: "interview-session",
    sessionConfig: OPENAI_LOW_LATENCY_SESSION_OPTIONS.sessionConfig,
  }),
});

const session = useRealtimeSession(adapter, {
  onStatusChange: (status) => {}, // Session connected/disconnected
  onAgentStatusChange: (status) => {}, // Agent idle/listening/speaking/thinking
  onError: (error) => {}, // Connection or runtime errors
  onTranscriptComplete: (entry) => {}, // Finalized transcript (user or assistant)
  onAgentHandoff: (agentName) => {}, // Agent-to-agent handoff
  onUserSpeechStart: () => {}, // User started speaking
  onUserSpeechStop: () => {}, // User stopped speaking
  onToolStart: (toolName, args) => {}, // Tool invocation started
  onToolEnd: (toolName, result) => {}, // Tool invocation finished
  onUsageUpdate: (usage) => {}, // Token usage changed
  onTransportEvent: (event) => {}, // Raw provider transport event
  onGuardrailTripped: (result) => {}, // Guardrail result (OpenAI)
  onToolApprovalRequest: async (name, args) => true, // Approve/reject tool calls
});

import {
  OPENAI_DEFAULT_CONTEXT_MANAGEMENT,
  OPENAI_LOW_LATENCY_CONTEXT_MANAGEMENT,
  OPENAI_DEFAULT_SESSION_OPTIONS,
  OPENAI_LOW_LATENCY_SESSION_OPTIONS,
  OPENAI_DEFAULT_TURN_DETECTION,
  OPENAI_INTERVIEW_TRANSCRIPTION_CONFIG,
  OPENAI_SPEECH_STYLE_HINTS,
  openAIAgentOptions,
  openAISessionOptions,
} from "@classytic/realtime-agents/openai";

import {
  GEMINI_DEFAULT_CONTEXT_MANAGEMENT,
  GEMINI_LOW_LATENCY_CONTEXT_MANAGEMENT,
  GEMINI_DEFAULT_SESSION_OPTIONS,
  GEMINI_LOW_LATENCY_SESSION_OPTIONS,
  geminiSessionOptions,
} from "@classytic/realtime-agents/gemini";

// OpenAI: keep 60% of context on truncation
new OpenAIAdapter({ contextManagement: { retentionRatio: 0.6 } });

// Gemini: custom trigger threshold
new GeminiAdapter({
  contextManagement: { triggerTokens: 80000, retentionRatio: 0.5 },
});

// Disable context management (not recommended for long sessions)
new OpenAIAdapter({ contextManagement: { mode: "disabled" } });

import {
  OpenAIAdapter,
  OPENAI_HIGH_ACCURACY_SESSION_OPTIONS,
  OPENAI_INTERVIEW_TRANSCRIPTION_CONFIG,
} from "@classytic/realtime-agents/openai";

const adapter = new OpenAIAdapter({
  sessionOptions: OPENAI_HIGH_ACCURACY_SESSION_OPTIONS,
  transcriptionModel: OPENAI_INTERVIEW_TRANSCRIPTION_CONFIG.model,
  transcriptionPrompt: OPENAI_INTERVIEW_TRANSCRIPTION_CONFIG.prompt,
});

const adapter = useMemo(() => new OpenAIAdapter(), []);

// After connect, get the analyser node
const analyser = adapter.getOutputAnalyser(); // AnalyserNode | null

// Reactive state (updates in real-time)
const { usage } = session;
console.log(usage?.inputTokens, usage?.outputTokens, usage?.totalTokens);
// Granular breakdown: usage?.inputTokensDetails, usage?.outputTokensDetails
// OpenAI also exposes usage?.requests when available
// Advanced analytics: usage?.rawUsage contains the provider-native payload

// Snapshot (e.g., before disconnect)
const snapshot = session.getUsage();

// OpenAI
import {
  OpenAIAdapter,
  OPENAI_VOICES,
  OPENAI_DEFAULT_VOICE,
  OPENAI_REALTIME_MODELS,
  OPENAI_DEFAULT_MODEL,
  OPENAI_TRANSCRIPTION_MODELS,
  OPENAI_DEFAULT_TRANSCRIPTION_MODEL,
  OPENAI_DEFAULT_TRANSCRIPTION_CONFIG,
  OPENAI_HIGH_ACCURACY_TRANSCRIPTION_CONFIG,
  OPENAI_INTERVIEW_TRANSCRIPTION_CONFIG,
  OPENAI_DEFAULT_SESSION_OPTIONS,
  OPENAI_HIGH_ACCURACY_SESSION_OPTIONS,
  OPENAI_LOW_LATENCY_SESSION_OPTIONS,
  OPENAI_TRANSPORTS,
  OPENAI_DEFAULT_TRANSPORT,
} from "@classytic/realtime-agents/openai";
import type {
  OpenAIAdapterOptions,
  OpenAIVoiceOption,
  OpenAIVoiceId,
  OpenAIRealtimeModel,
  OpenAIRealtimeModelId,
  OpenAITransport,
} from "@classytic/realtime-agents/openai";

// Gemini
import {
  GeminiAdapter,
  GEMINI_VOICES,
  GEMINI_DEFAULT_VOICE,
  GEMINI_LIVE_MODELS,
  GEMINI_DEFAULT_MODEL,
  GEMINI_TRANSPORTS,
  GEMINI_DEFAULT_TRANSPORT,
} from "@classytic/realtime-agents/gemini";
import type {
  GeminiAdapterOptions,
  GeminiVoiceOption,
  GeminiVoiceId,
  GeminiLiveModel,
  GeminiLiveModelId,
  GeminiTransport,
} from "@classytic/realtime-agents/gemini";

// Gemini also re-exports audio utilities
import {
  base64ToUint8Array,
  uint8ArrayToBase64,
  createPcmBlob,
  decodeAudioData,
  getAudioWorkletUrl,
  RECORDER_WORKLET_CODE,
} from "@classytic/realtime-agents/gemini";