import { renderHook, act } from '@testing-library/react'
import { useColumnReorder } from '../../hooks/useColumnReorder'
import { ColumnConfig } from '../../types'

type TestData = { id: string; name: string; value: number }

const createColumns = (): ColumnConfig<TestData>[] => [
  { id: 'id', header: 'ID', accessorKey: 'id' },
  { id: 'name', header: 'Name', accessorKey: 'name' },
  { id: 'value', header: 'Value', accessorKey: 'value' },
]

describe('useColumnReorder', () => {
  describe('initialization', () => {
    it('should return columns in default order when no initial order provided', () => {
      const columns = createColumns()
      const { result } = renderHook(() =>
        useColumnReorder({
          columns,
          enabled: true,
        })
      )

      expect(result.current.orderedColumns.map(c => c.id)).toEqual(['id', 'name', 'value'])
      expect(result.current.columnOrder).toEqual(['id', 'name', 'value'])
    })

    it('should apply initial order when provided', () => {
      const columns = createColumns()
      const { result } = renderHook(() =>
        useColumnReorder({
          columns,
          initialOrder: ['value', 'id', 'name'],
          enabled: true,
        })
      )

      expect(result.current.orderedColumns.map(c => c.id)).toEqual(['value', 'id', 'name'])
      expect(result.current.columnOrder).toEqual(['value', 'id', 'name'])
    })

    it('should filter out invalid column IDs from initial order', () => {
      const columns = createColumns()
      const { result } = renderHook(() =>
        useColumnReorder({
          columns,
          initialOrder: ['value', 'invalid', 'id', 'name'],
          enabled: true,
        })
      )

      expect(result.current.orderedColumns.map(c => c.id)).toEqual(['value', 'id', 'name'])
    })

    it('should append new columns not in initial order', () => {
      const columns = createColumns()
      const { result } = renderHook(() =>
        useColumnReorder({
          columns,
          initialOrder: ['value', 'id'], // 'name' is missing
          enabled: true,
        })
      )

      expect(result.current.orderedColumns.map(c => c.id)).toEqual(['value', 'id', 'name'])
    })

    it('should return original columns when disabled', () => {
      const columns = createColumns()
      const { result } = renderHook(() =>
        useColumnReorder({
          columns,
          initialOrder: ['value', 'id', 'name'],
          enabled: false,
        })
      )

      // When disabled, returns columns in their original order
      expect(result.current.orderedColumns.map(c => c.id)).toEqual(['id', 'name', 'value'])
    })
  })

  describe('handleDragEnd', () => {
    it('should reorder columns when dragging', () => {
      const columns = createColumns()
      const onOrderChange = jest.fn()
      const { result } = renderHook(() =>
        useColumnReorder({
          columns,
          enabled: true,
          onOrderChange,
        })
      )

      act(() => {
        result.current.handleDragEnd({
          source: { index: 0, droppableId: 'columns' },
          destination: { index: 2, droppableId: 'columns' },
          draggableId: 'id',
          type: 'DEFAULT',
          mode: 'FLUID',
          reason: 'DROP',
          combine: null,
        })
      })

      // 'id' moved from index 0 to index 2
      expect(result.current.orderedColumns.map(c => c.id)).toEqual(['name', 'value', 'id'])
      expect(onOrderChange).toHaveBeenCalledWith(['name', 'value', 'id'])
    })

    it('should not reorder when dropped in same position', () => {
      const columns = createColumns()
      const onOrderChange = jest.fn()
      const { result } = renderHook(() =>
        useColumnReorder({
          columns,
          enabled: true,
          onOrderChange,
        })
      )

      act(() => {
        result.current.handleDragEnd({
          source: { index: 1, droppableId: 'columns' },
          destination: { index: 1, droppableId: 'columns' },
          draggableId: 'name',
          type: 'DEFAULT',
          mode: 'FLUID',
          reason: 'DROP',
          combine: null,
        })
      })

      expect(result.current.orderedColumns.map(c => c.id)).toEqual(['id', 'name', 'value'])
      expect(onOrderChange).not.toHaveBeenCalled()
    })

    it('should not reorder when destination is null (cancelled drag)', () => {
      const columns = createColumns()
      const onOrderChange = jest.fn()
      const { result } = renderHook(() =>
        useColumnReorder({
          columns,
          enabled: true,
          onOrderChange,
        })
      )

      act(() => {
        result.current.handleDragEnd({
          source: { index: 0, droppableId: 'columns' },
          destination: null,
          draggableId: 'id',
          type: 'DEFAULT',
          mode: 'FLUID',
          reason: 'CANCEL',
          combine: null,
        })
      })

      expect(result.current.orderedColumns.map(c => c.id)).toEqual(['id', 'name', 'value'])
      expect(onOrderChange).not.toHaveBeenCalled()
    })
  })

  describe('resetOrder', () => {
    it('should reset to default column order', () => {
      const columns = createColumns()
      const onOrderChange = jest.fn()
      const { result } = renderHook(() =>
        useColumnReorder({
          columns,
          initialOrder: ['value', 'id', 'name'],
          enabled: true,
          onOrderChange,
        })
      )

      // Verify initial custom order
      expect(result.current.orderedColumns.map(c => c.id)).toEqual(['value', 'id', 'name'])

      act(() => {
        result.current.resetOrder()
      })

      expect(result.current.orderedColumns.map(c => c.id)).toEqual(['id', 'name', 'value'])
      expect(onOrderChange).toHaveBeenCalledWith(['id', 'name', 'value'])
    })
  })
})