'use client'

import {
  closestCenter,
  DndContext,
  type DragEndEvent,
  DragOverlay,
  type DragStartEvent,
  PointerSensor,
  useSensor,
  useSensors,
} from '@dnd-kit/core'
import {
  arrayMove,
  horizontalListSortingStrategy,
  SortableContext,
  useSortable,
} from '@dnd-kit/sortable'
import { CSS } from '@dnd-kit/utilities'
import { Loader2, Pencil, Plus, Power, PowerOff, Trash2 } from 'lucide-react'
import { useCallback, useState } from 'react'
import { toast } from 'sonner'
import { deleteTreePage, reorderTreePage, toggleCatalogPage } from '@/actions/catalog'
import { CatalogIcon } from '@/components/admin/catalog-tree'
import { Button } from '@/components/ui/button'
import {
  ContextMenu,
  ContextMenuContent,
  ContextMenuItem,
  ContextMenuSeparator,
  ContextMenuTrigger,
} from '@/components/ui/context-menu'
import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
import { cn } from '@/lib/utils'

export type { RootTab } from '@/types/catalog'

import type { RootTab } from '@/types/catalog'

interface RootTabsProps {
  tabs: RootTab[]
  activeTabId: number | null
  onTabClick: (id: number) => void
  onEditTab: (id: number) => void
  onCreateRoot: () => void
  loading?: boolean
}

export function RootTabs({
  tabs,
  activeTabId,
  onTabClick,
  onEditTab,
  onCreateRoot,
  loading,
}: RootTabsProps) {
  const [activeDragId, setActiveDragId] = useState<number | null>(null)
  const sensors = useSensors(useSensor(PointerSensor, { activationConstraint: { distance: 8 } }))

  const handleDragStart = useCallback((event: DragStartEvent) => {
    setActiveDragId(event.active.id as number)
  }, [])

  const handleDragEnd = useCallback(
    async (event: DragEndEvent) => {
      const { active, over } = event
      setActiveDragId(null)
      if (!over || active.id === over.id) return

      const oldIndex = tabs.findIndex((t) => t.id === active.id)
      const newIndex = tabs.findIndex((t) => t.id === over.id)
      if (oldIndex === -1 || newIndex === -1) return

      const newOrder = arrayMove(tabs, oldIndex, newIndex)

      // Batch reorder
      try {
        const results = await Promise.allSettled(
          newOrder.map((tab, idx) => reorderTreePage({ pageId: tab.id, newOrderNum: idx + 1 })),
        )
        const failed = results.filter((r) => r.status === 'rejected').length
        if (failed) toast.error(`${failed} reorder(s) failed`)
        else toast.success('Tabs reordered')
      } catch {
        toast.error('Failed to reorder tabs')
      }
    },
    [tabs],
  )

  const handleToggle = async (tab: RootTab) => {
    try {
      await toggleCatalogPage({ id: tab.id, action: 'toggleEnabled' })
      toast.success(`${tab.caption} ${tab.enabled === '1' ? 'disabled' : 'enabled'}`)
    } catch {
      toast.error('Failed to toggle')
    }
  }

  const handleDelete = async (tab: RootTab) => {
    if (!confirm(`Delete root page "${tab.caption}"? Children will be reparented.`)) return
    try {
      await deleteTreePage({ pageId: tab.id, mode: 'reparent' })
      toast.success(`"${tab.caption}" deleted`)
    } catch {
      toast.error('Failed to delete')
    }
  }

  const draggedTab = activeDragId ? tabs.find((t) => t.id === activeDragId) : null

  return (
    <div className="flex items-center gap-1 border-b bg-muted/30 px-2 py-1.5 overflow-x-auto shrink-0">
      {loading && <Loader2 className="h-4 w-4 animate-spin text-muted-foreground mx-2" />}
      <DndContext
        sensors={sensors}
        collisionDetection={closestCenter}
        onDragStart={handleDragStart}
        onDragEnd={handleDragEnd}
      >
        <SortableContext items={tabs.map((t) => t.id)} strategy={horizontalListSortingStrategy}>
          {tabs.map((tab) => (
            <SortableRootTab
              key={tab.id}
              tab={tab}
              isActive={activeTabId === tab.id}
              onClick={() => onTabClick(tab.id)}
              onEdit={() => onEditTab(tab.id)}
              onToggle={() => handleToggle(tab)}
              onDelete={() => handleDelete(tab)}
            />
          ))}
        </SortableContext>
        <DragOverlay>
          {draggedTab && (
            <TabButton tab={draggedTab} isActive={activeTabId === draggedTab.id} isOverlay />
          )}
        </DragOverlay>
      </DndContext>
      <Tooltip>
        <TooltipTrigger asChild>
          <Button
            variant="ghost"
            size="icon"
            className="h-7 w-7 shrink-0 ml-1"
            onClick={onCreateRoot}
          >
            <Plus className="h-3.5 w-3.5" />
          </Button>
        </TooltipTrigger>
        <TooltipContent>
          <p>New root page</p>
        </TooltipContent>
      </Tooltip>
    </div>
  )
}

// ── Sortable root tab ─────────────────────────────────────────

function SortableRootTab({
  tab,
  isActive,
  onClick,
  onEdit,
  onToggle,
  onDelete,
}: {
  tab: RootTab
  isActive: boolean
  onClick: () => void
  onEdit: () => void
  onToggle: () => void
  onDelete: () => void
}) {
  const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({
    id: tab.id,
  })

  const style: React.CSSProperties = {
    transform: CSS.Transform.toString(transform),
    transition,
    opacity: isDragging ? 0.3 : 1,
  }

  return (
    <ContextMenu>
      <ContextMenuTrigger asChild>
        <div ref={setNodeRef} style={style} {...attributes} {...listeners}>
          <TabButton tab={tab} isActive={isActive} onClick={onClick} onDoubleClick={onEdit} />
        </div>
      </ContextMenuTrigger>
      <ContextMenuContent className="w-44">
        <ContextMenuItem onClick={onEdit}>
          <Pencil className="mr-2 h-3.5 w-3.5" />
          Edit page
        </ContextMenuItem>
        <ContextMenuSeparator />
        <ContextMenuItem onClick={onToggle}>
          {tab.enabled === '1' ? (
            <PowerOff className="mr-2 h-3.5 w-3.5" />
          ) : (
            <Power className="mr-2 h-3.5 w-3.5" />
          )}
          {tab.enabled === '1' ? 'Disable' : 'Enable'}
        </ContextMenuItem>
        <ContextMenuSeparator />
        <ContextMenuItem className="text-destructive focus:text-destructive" onClick={onDelete}>
          <Trash2 className="mr-2 h-3.5 w-3.5" />
          Delete
        </ContextMenuItem>
      </ContextMenuContent>
    </ContextMenu>
  )
}

// ── Tab button render ─────────────────────────────────────────

function TabButton({
  tab,
  isActive,
  isOverlay,
  onClick,
  onDoubleClick,
}: {
  tab: RootTab
  isActive: boolean
  isOverlay?: boolean
  onClick?: () => void
  onDoubleClick?: () => void
}) {
  return (
    <button
      type="button"
      onClick={onClick}
      onDoubleClick={onDoubleClick}
      className={cn(
        'flex items-center gap-1.5 px-3 py-1.5 rounded-md text-sm font-medium transition-colors whitespace-nowrap shrink-0',
        isActive
          ? 'bg-primary text-primary-foreground shadow-sm'
          : 'hover:bg-accent text-muted-foreground hover:text-foreground',
        tab.enabled !== '1' && 'opacity-50',
        isOverlay && 'bg-card shadow-lg border',
      )}
    >
      <CatalogIcon iconImage={tab.iconImage} size={16} />
      <span className="max-w-32 truncate">{tab.caption}</span>
    </button>
  )
}