import { createSelector } from '../utils'
import type { StoreSimpleSelectors } from '../selectors'
import type { GridState } from '../types'
import type { GridRowId } from '../../types'
import { calculateHitAreas } from '../../data-tools/calculate-hit-areas'
import { SELECTION_COLUMN_ID } from '../../constants'

export default function generateSelectors(
    selectors: Pick<
        StoreSimpleSelectors,
        | 'selectCanConvertLeaf'
        | 'selectDraggingRowIds'
        | 'selectDragMode'
        | 'selectIsTreeGrid'
        | 'selectRowCollection'
        | 'selectRowHeight'
        | 'selectRowLevelMap'
        | 'selectColumnIdsWithHidden'
        | 'selectHiddenIds'
        | 'selectColumn'
        | 'selectConfiguredPreviewColumnId'
        | 'selectTreeIndentSize'
    >,
    selectRowIds: (state: GridState) => GridRowId[]
) {
    const selectPreviewColumnId = (state: GridState) => {
        const columnIds = selectors.selectColumnIdsWithHidden(state)
        const hiddenIds = selectors.selectHiddenIds(state)
        const visibleColumnIds = columnIds.filter((c) => !hiddenIds.includes(c))

        const configuredPreviewColumnId =
            selectors.selectConfiguredPreviewColumnId(state)

        if (
            configuredPreviewColumnId == null ||
            !visibleColumnIds.includes(configuredPreviewColumnId)
        ) {
            return visibleColumnIds.find((c) => c !== SELECTION_COLUMN_ID)
        }

        return configuredPreviewColumnId
    }

    const selectPreviewLeftOffset = (state: GridState) => {
        const columnIdsWithHidden = selectors.selectColumnIdsWithHidden(state)
        if (columnIdsWithHidden[0] === SELECTION_COLUMN_ID) {
            return (
                selectors.selectColumn(state, SELECTION_COLUMN_ID)
                    ?.actualWidth ?? 0
            )
        }
        return 0
    }

    const selectCollisionAreas = createSelector(
        [
            selectors.selectCanConvertLeaf,
            selectors.selectDraggingRowIds,
            selectors.selectDragMode,
            selectors.selectIsTreeGrid,
            selectPreviewLeftOffset,
            selectors.selectRowCollection,
            selectors.selectRowHeight,
            selectRowIds,
            selectors.selectRowLevelMap,
            selectors.selectTreeIndentSize,
        ],
        (
            canConvertLeaf,
            draggingRowIds,
            mode,
            isTreeGrid,
            previewColumnOffset,
            rowCollection,
            rowHeight,
            rowIds,
            levelMap,
            treeIndentSize
        ) => {
            if (!draggingRowIds.size) {
                return { collisions: [], maxBottom: 0, maxTop: 0 }
            }

            return calculateHitAreas({
                canConvertLeaf,
                draggingRowIds,
                mode,
                isTreeGrid,
                previewColumnOffset,
                rowCollection,
                rowHeight,
                rowIds,
                levelMap,
                treeIndentSize,
            })
        }
    )

    return {
        selectCollisionAreas,
        selectPreviewColumnId,
        selectPreviewLeftOffset,
    }
}

export type SelectCollisionAreas = ReturnType<
    typeof generateSelectors
>['selectCollisionAreas']

export type SelectPreviewColumnId = ReturnType<
    typeof generateSelectors
>['selectPreviewColumnId']

export type SelectPreviewLeftOffset = ReturnType<
    typeof generateSelectors
>['selectPreviewLeftOffset']