import type { VariableAssignerNodeType } from '../types'
import type { InputVar } from '@/app/components/workflow/types'
import { renderHook } from '@testing-library/react'
import { BlockEnum, InputVarType, VarType } from '@/app/components/workflow/types'
import useSingleRunFormParams from '../use-single-run-form-params'

const createData = (
  overrides: Partial<VariableAssignerNodeType> = {},
): VariableAssignerNodeType => ({
  title: 'Variable Assigner',
  desc: '',
  type: BlockEnum.VariableAssigner,
  output_type: VarType.string,
  variables: [['source-node', 'rootVar']],
  advanced_settings: {
    group_enabled: true,
    groups: [
      {
        groupId: 'group-1',
        group_name: 'Group1',
        output_type: VarType.string,
        variables: [
          ['source-node', 'sharedVar'],
          ['source-node', 'uniqueVar'],
        ],
      },
      {
        groupId: 'group-2',
        group_name: 'Group2',
        output_type: VarType.number,
        variables: [['source-node', 'sharedVar']],
      },
    ],
  },
  ...overrides,
})

describe('variable-assigner/use-single-run-form-params', () => {
  it('deduplicates grouped variable inputs and marks them optional for single run', () => {
    const setRunInputData = vi.fn()
    const varSelectorsToVarInputs = vi.fn<() => InputVar[]>(() => [
      {
        label: 'Shared',
        variable: 'sharedVar',
        type: InputVarType.textInput,
        required: true,
      },
      {
        label: 'Unique',
        variable: 'uniqueVar',
        type: InputVarType.number,
        required: true,
      },
      {
        label: 'Shared duplicate',
        variable: 'sharedVar',
        type: InputVarType.textInput,
        required: true,
      },
    ])

    const { result } = renderHook(() =>
      useSingleRunFormParams({
        id: 'assigner-node',
        payload: createData(),
        runInputData: { sharedVar: 'hello' },
        runInputDataRef: { current: {} },
        getInputVars: () => [],
        setRunInputData,
        toVarInputs: () => [],
        varSelectorsToVarInputs,
      }),
    )

    expect(varSelectorsToVarInputs).toHaveBeenCalledWith([
      ['source-node', 'sharedVar'],
      ['source-node', 'uniqueVar'],
      ['source-node', 'sharedVar'],
    ])
    expect(result.current.forms[0]!.inputs).toEqual([
      {
        label: 'Shared',
        variable: 'sharedVar',
        type: InputVarType.textInput,
        required: false,
      },
      {
        label: 'Unique',
        variable: 'uniqueVar',
        type: InputVarType.number,
        required: false,
      },
    ])

    result.current.forms[0]!.onChange({ sharedVar: 'updated' })

    expect(setRunInputData).toHaveBeenCalledWith({ sharedVar: 'updated' })
    expect(result.current.getDependentVars()).toEqual([
      [
        ['source-node', 'sharedVar'],
        ['source-node', 'uniqueVar'],
      ],
      [['source-node', 'sharedVar']],
    ])
  })

  it('returns root variables directly when grouping is disabled', () => {
    const { result } = renderHook(() =>
      useSingleRunFormParams({
        id: 'assigner-node',
        payload: createData({
          advanced_settings: {
            group_enabled: false,
            groups: [],
          },
          variables: [['source-node', 'rootVar']],
        }),
        runInputData: {},
        runInputDataRef: { current: {} },
        getInputVars: () => [],
        setRunInputData: vi.fn(),
        toVarInputs: () => [],
        varSelectorsToVarInputs: () => [],
      }),
    )

    expect(result.current.getDependentVars()).toEqual([[['source-node', 'rootVar']]])
  })
})
