{
  "query": "tonic ui registry"
}
"use client"

import { useCallback, useState, type FC, type PropsWithChildren } from "react"
import {
  AlertCircleIcon,
  CheckIcon,
  ChevronDownIcon,
  LoaderIcon,
  XCircleIcon,
} from "lucide-react"

import {
  Collapsible,
  CollapsibleContent,
  CollapsibleTrigger,
} from "@/registry/tonic/ui/collapsible"
import { Button } from "@/registry/tonic/ui/button"
import { Textarea } from "@/registry/tonic/ui/textarea"
import { cn } from "@/lib/utils"

const ANIMATION_DURATION = 200

export type ToolFallbackStatusType =
  | "running"
  | "complete"
  | "incomplete"
  | "requires-action"

export type ToolFallbackStatus = {
  type: ToolFallbackStatusType
  reason?: string
  error?: unknown
}

export type ToolFallbackRootProps = Omit<
  React.ComponentProps<typeof Collapsible>,
  "open" | "onOpenChange"
> & {
  open?: boolean
  onOpenChange?: (open: boolean) => void
  defaultOpen?: boolean
}

function ToolFallbackRoot({
  className,
  open: controlledOpen,
  onOpenChange: controlledOnOpenChange,
  defaultOpen = false,
  children,
  ...props
}: ToolFallbackRootProps) {
  const [uncontrolledOpen, setUncontrolledOpen] = useState(defaultOpen)
  const isControlled = controlledOpen !== undefined
  const isOpen = isControlled ? controlledOpen : uncontrolledOpen

  const handleOpenChange = useCallback(
    (next: boolean) => {
      if (!isControlled) setUncontrolledOpen(next)
      controlledOnOpenChange?.(next)
    },
    [isControlled, controlledOnOpenChange]
  )

  return (
    <Collapsible
      data-slot="tool-fallback-root"
      open={isOpen}
      onOpenChange={handleOpenChange}
      className={cn("group/tool-fallback-root w-full", className)}
      style={
        {
          "--animation-duration": `${ANIMATION_DURATION}ms`,
        } as React.CSSProperties
      }
      {...props}
    >
      {children}
    </Collapsible>
  )
}

const statusIconMap: Record<ToolFallbackStatusType, React.ElementType> = {
  running: LoaderIcon,
  complete: CheckIcon,
  incomplete: XCircleIcon,
  "requires-action": AlertCircleIcon,
}

export function formatToolDuration(ms: number) {
  if (ms < 1000) return "<1s"
  const seconds = ms / 1000
  if (seconds < 10) return `${(Math.floor(seconds * 10) / 10).toFixed(1)}s`
  if (seconds < 60) return `${Math.floor(seconds)}s`
  return `${Math.floor(seconds / 60)}m ${Math.floor(seconds % 60)}s`
}

function ToolFallbackTrigger({
  toolName,
  status,
  elapsedMs,
  className,
  ...props
}: React.ComponentProps<typeof CollapsibleTrigger> & {
  toolName: string
  status?: ToolFallbackStatus
  elapsedMs?: number
}) {
  const statusType = status?.type ?? "complete"
  const isRunning = statusType === "running"
  const isCancelled =
    status?.type === "incomplete" && status.reason === "cancelled"
  const Icon = statusIconMap[statusType]
  const label = isCancelled
    ? `Cancelled ${toolName}`
    : isRunning
      ? `Running ${toolName}`
      : toolName

  return (
    <CollapsibleTrigger
      data-slot="tool-fallback-trigger"
      className={cn(
        "group/trigger text-muted-foreground hover:text-foreground/70 flex w-fit origin-left items-center gap-1.5 py-0.5 text-[15px] leading-6 transition-[color,scale] active:scale-[0.98]",
        className
      )}
      {...props}
    >
      <Icon
        className={cn(
          "size-3.5 shrink-0 opacity-70",
          isCancelled && "text-muted-foreground",
          isRunning && "animate-spin [animation-duration:0.6s]"
        )}
      />
      <span
        className={cn(
          "inline-block text-start font-normal",
          isCancelled && "text-muted-foreground line-through",
          isRunning && "shimmer motion-reduce:animate-none"
        )}
      >
        {label}
      </span>
      {elapsedMs !== undefined ? (
        <span className="text-muted-foreground text-[15px] leading-6 tabular-nums opacity-80">
          {formatToolDuration(elapsedMs)}
        </span>
      ) : null}
      <ChevronDownIcon
        className={cn(
          "size-3.5 shrink-0 opacity-50 transition-transform duration-(--animation-duration) ease-[cubic-bezier(0.32,0.72,0,1)] motion-reduce:transition-none",
          "-rotate-90 group-data-[state=open]/tool-fallback-root:rotate-0"
        )}
      />
    </CollapsibleTrigger>
  )
}

function ToolFallbackContent({
  className,
  children,
  ...props
}: React.ComponentProps<typeof CollapsibleContent>) {
  return (
    <CollapsibleContent
      data-slot="tool-fallback-content"
      className={cn("relative overflow-hidden text-sm outline-none", className)}
      {...props}
    >
      <div className="flex flex-col gap-2 ps-6 pt-1 pb-2">{children}</div>
    </CollapsibleContent>
  )
}

function ToolFallbackArgs({
  argsText,
  className,
  ...props
}: React.ComponentProps<"div"> & { argsText?: string }) {
  if (!argsText) return null
  return (
    <div data-slot="tool-fallback-args" className={cn(className)} {...props}>
      <pre className="bg-muted/50 text-foreground/90 rounded-md p-2.5 text-xs whitespace-pre-wrap">
        {argsText}
      </pre>
    </div>
  )
}

function formatUnknownValue(value: unknown, space?: number): string {
  if (typeof value === "string") return value
  try {
    if (value instanceof Error) return String(value)
    const json = JSON.stringify(value, null, space)
    if (json !== undefined) return json
  } catch {
    /* ignore */
  }
  try {
    return String(value)
  } catch {
    return "[Unserializable value]"
  }
}

function ToolFallbackResult({
  result,
  className,
  ...props
}: React.ComponentProps<"div"> & { result?: unknown }) {
  if (result === undefined) return null
  return (
    <div data-slot="tool-fallback-result" className={cn(className)} {...props}>
      <p className="text-muted-foreground text-xs font-medium">Result:</p>
      <pre className="bg-muted/50 text-foreground/90 mt-1 rounded-md p-2.5 text-xs whitespace-pre-wrap">
        {formatUnknownValue(result, 2)}
      </pre>
    </div>
  )
}

function ToolFallbackError({
  status,
  className,
  ...props
}: React.ComponentProps<"div"> & { status?: ToolFallbackStatus }) {
  if (status?.type !== "incomplete") return null
  const error = status.error
  const errorText =
    error === undefined || error === null ? null : formatUnknownValue(error)
  if (!errorText) return null
  const isCancelled = status.reason === "cancelled"
  return (
    <div data-slot="tool-fallback-error" className={cn(className)} {...props}>
      <p className="text-muted-foreground font-semibold">
        {isCancelled ? "Cancelled reason:" : "Error:"}
      </p>
      <p className="text-muted-foreground">{errorText}</p>
    </div>
  )
}

export type ToolFallbackApprovalProps = {
  onApprove?: (feedback?: string) => void
  onDeny?: (feedback?: string) => void
  acceptsText?: boolean
  className?: string
}

function ToolFallbackApproval({
  onApprove,
  onDeny,
  acceptsText = false,
  className,
}: ToolFallbackApprovalProps) {
  const [feedback, setFeedback] = useState("")
  if (!onApprove && !onDeny) return null

  return (
    <div
      data-slot="tool-fallback-approval"
      className={cn("flex flex-col gap-2", className)}
    >
      {acceptsText ? (
        <Textarea
          value={feedback}
          onChange={(event) => setFeedback(event.target.value)}
          placeholder="Optional note"
          className="min-h-16 text-sm"
        />
      ) : null}
      <div className="flex flex-wrap gap-2">
        {onApprove ? (
          <Button
            type="button"
            size="sm"
            onClick={() => onApprove(feedback || undefined)}
          >
            Allow
          </Button>
        ) : null}
        {onDeny ? (
          <Button
            type="button"
            size="sm"
            variant="outline"
            onClick={() => onDeny(feedback || undefined)}
          >
            Deny
          </Button>
        ) : null}
      </div>
    </div>
  )
}

const ToolFallback: FC<
  PropsWithChildren<{
    toolName: string
    status?: ToolFallbackStatus
    elapsedMs?: number
    argsText?: string
    result?: unknown
    defaultOpen?: boolean
    onApprove?: (feedback?: string) => void
    onDeny?: (feedback?: string) => void
    acceptsText?: boolean
  }>
> & {
  Root: typeof ToolFallbackRoot
  Trigger: typeof ToolFallbackTrigger
  Content: typeof ToolFallbackContent
  Args: typeof ToolFallbackArgs
  Result: typeof ToolFallbackResult
  Error: typeof ToolFallbackError
  Approval: typeof ToolFallbackApproval
} = ({
  toolName,
  status,
  elapsedMs,
  argsText,
  result,
  defaultOpen,
  onApprove,
  onDeny,
  acceptsText,
  children,
}) => (
  <ToolFallbackRoot defaultOpen={defaultOpen}>
    <ToolFallbackTrigger
      toolName={toolName}
      status={status}
      elapsedMs={elapsedMs}
    />
    <ToolFallbackContent>
      <ToolFallbackError status={status} />
      <ToolFallbackArgs argsText={argsText} />
      {status?.type === "requires-action" ? (
        <ToolFallbackApproval
          onApprove={onApprove}
          onDeny={onDeny}
          acceptsText={acceptsText}
        />
      ) : null}
      <ToolFallbackResult result={result} />
      {children}
    </ToolFallbackContent>
  </ToolFallbackRoot>
)

ToolFallback.Root = ToolFallbackRoot
ToolFallback.Trigger = ToolFallbackTrigger
ToolFallback.Content = ToolFallbackContent
ToolFallback.Args = ToolFallbackArgs
ToolFallback.Result = ToolFallbackResult
ToolFallback.Error = ToolFallbackError
ToolFallback.Approval = ToolFallbackApproval

export {
  ToolFallback,
  ToolFallbackRoot,
  ToolFallbackTrigger,
  ToolFallbackContent,
  ToolFallbackArgs,
  ToolFallbackResult,
  ToolFallbackError,
  ToolFallbackApproval,
}