"use client"

import { useCallback, useState, type FC, type PropsWithChildren } from "react"
import { ChevronDownIcon, LoaderIcon } from "lucide-react"
import { cva, type VariantProps } from "class-variance-authority"

import {
  Collapsible,
  CollapsibleContent,
  CollapsibleTrigger,
} from "@/registry/tonic/ui/collapsible"
import { cn } from "@/lib/utils"
import { getToolPresentation } from "@/registry/tonic/tool-presentation/tool-presentation"

const ANIMATION_DURATION = 200

const toolGroupVariants = cva("group/tool-group w-full", {
  variants: {
    variant: {
      outline: "rounded-lg border py-3",
      ghost: "",
      muted: "border-muted-foreground/30 bg-muted/30 rounded-lg border py-3",
    },
  },
  defaultVariants: { variant: "ghost" },
})

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

function ToolGroupRoot({
  className,
  variant,
  open: controlledOpen,
  onOpenChange: controlledOnOpenChange,
  defaultOpen = false,
  children,
  ...props
}: ToolGroupRootProps) {
  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-group-root"
      data-variant={variant ?? "ghost"}
      open={isOpen}
      onOpenChange={handleOpenChange}
      className={cn(
        toolGroupVariants({ variant }),
        "group/tool-group-root",
        className
      )}
      style={
        {
          "--animation-duration": `${ANIMATION_DURATION}ms`,
        } as React.CSSProperties
      }
      {...props}
    >
      {children}
    </Collapsible>
  )
}

function ToolGroupTrigger({
  count,
  active = false,
  toolName,
  statusHint,
  className,
  ...props
}: React.ComponentProps<typeof CollapsibleTrigger> & {
  count: number
  active?: boolean
  toolName?: string
  statusHint?: string
}) {
  const presentation = toolName ? getToolPresentation(toolName) : null
  const label =
    count === 1 && presentation
      ? presentation.label
      : `${count} tool ${count === 1 ? "call" : "calls"}`
  const Icon = presentation?.icon

  return (
    <CollapsibleTrigger
      data-slot="tool-group-trigger"
      className={cn(
        "group/trigger flex origin-left items-center gap-1.5 text-[15px] leading-6 transition-[color,scale] active:scale-[0.98]",
        "group-data-[variant=ghost]/tool-group-root:text-muted-foreground group-data-[variant=ghost]/tool-group-root:hover:text-foreground/70 group-data-[variant=ghost]/tool-group-root:py-0.5",
        "group-data-[variant=outline]/tool-group-root:w-full group-data-[variant=outline]/tool-group-root:px-4",
        "group-data-[variant=muted]/tool-group-root:w-full group-data-[variant=muted]/tool-group-root:px-4",
        className
      )}
      {...props}
    >
      {active ? (
        <LoaderIcon className="size-3 shrink-0 animate-spin [animation-duration:0.6s]" />
      ) : Icon ? (
        <Icon className="size-3.5 shrink-0 opacity-70" />
      ) : null}
      <span
        className={cn(
          "inline-block text-start text-[15px] leading-6 font-normal",
          active && "shimmer motion-reduce:animate-none"
        )}
      >
        {label}
        {statusHint ? (
          <span className="text-muted-foreground/70 ms-1.5 text-[13px]">
            {statusHint}
          </span>
        ) : null}
      </span>
      <ChevronDownIcon
        className={cn(
          "size-3 shrink-0 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-group-root:rotate-0"
        )}
      />
    </CollapsibleTrigger>
  )
}

function ToolGroupContent({
  className,
  children,
  ...props
}: React.ComponentProps<typeof CollapsibleContent>) {
  return (
    <CollapsibleContent
      data-slot="tool-group-content"
      className={cn(
        "relative overflow-hidden text-sm outline-none",
        "data-[state=closed]:animate-out data-[state=open]:animate-in",
        className
      )}
      {...props}
    >
      <div
        className={cn(
          "mt-2 flex flex-col gap-2",
          "group-data-[variant=ghost]/tool-group-root:mt-1 group-data-[variant=ghost]/tool-group-root:gap-1",
          "group-data-[variant=outline]/tool-group-root:mt-3 group-data-[variant=outline]/tool-group-root:border-t group-data-[variant=outline]/tool-group-root:px-4 group-data-[variant=outline]/tool-group-root:pt-3",
          "group-data-[variant=muted]/tool-group-root:mt-3 group-data-[variant=muted]/tool-group-root:border-t group-data-[variant=muted]/tool-group-root:px-4 group-data-[variant=muted]/tool-group-root:pt-3"
        )}
      >
        {children}
      </div>
    </CollapsibleContent>
  )
}

/** Convenience wrapper for a counted tool group. */
const ToolGroup: FC<
  PropsWithChildren<{
    count: number
    active?: boolean
    toolName?: string
    statusHint?: string
    variant?: ToolGroupRootProps["variant"]
    defaultOpen?: boolean
  }>
> & {
  Root: typeof ToolGroupRoot
  Trigger: typeof ToolGroupTrigger
  Content: typeof ToolGroupContent
} = ({
  count,
  active,
  toolName,
  statusHint,
  variant,
  defaultOpen,
  children,
}) => (
  <ToolGroupRoot variant={variant} defaultOpen={defaultOpen}>
    <ToolGroupTrigger
      count={count}
      active={active}
      toolName={toolName}
      statusHint={statusHint}
    />
    <ToolGroupContent>{children}</ToolGroupContent>
  </ToolGroupRoot>
)

ToolGroup.Root = ToolGroupRoot
ToolGroup.Trigger = ToolGroupTrigger
ToolGroup.Content = ToolGroupContent

export {
  ToolGroup,
  ToolGroupRoot,
  ToolGroupTrigger,
  ToolGroupContent,
  toolGroupVariants,
}