import type { GridState } from '..'
import { INITIAL_STATE } from '..'
import { jest } from '@jest/globals'
import type { StoreSimpleSelectors } from '../selectors'
import type {
    SelectRowIds,
    SelectRowIndex,
    SelectAriaRowCount,
    SelectAriaSetSize,
    SelectAriaPosInset,
    SelectColumnSpanByRowId,
} from './row'
import generateSelectors from './row'
import type { SelectSortFn } from './sort'
import type { SelectFilterMatchesShowOnly } from './filter'
import type { SelectColSpanConfig, SelectStickyColumnIds } from './column'

const state = {} as GridState

describe('compositeSelectors - row', () => {
    let selectRowIds: SelectRowIds
    let selectRowIndex: SelectRowIndex
    let selectAriaRowCount: SelectAriaRowCount
    let selectAriaSetSize: SelectAriaSetSize
    let selectAriaPosInset: SelectAriaPosInset
    let selectColumnSpanByRowId: SelectColumnSpanByRowId

    let selectHeaderHierarchy: jest.Mock<
        StoreSimpleSelectors['selectHeaderHierarchy']
    >

    let selectRowCollection: jest.Mock<
        StoreSimpleSelectors['selectRowCollection']
    >
    let selectRowsExpanded: jest.Mock<
        StoreSimpleSelectors['selectRowsExpanded']
    >
    let selectIsTreeGrid: jest.Mock<StoreSimpleSelectors['selectIsTreeGrid']>
    let selectRow: jest.Mock<StoreSimpleSelectors['selectRow']>
    let selectRowMeta: jest.Mock<StoreSimpleSelectors['selectRowMeta']>
    let selectSortFn: jest.Mock<SelectSortFn>
    let selectFilterMatchesShowOnly: jest.Mock<SelectFilterMatchesShowOnly>
    let selectColSpanConfig: jest.Mock<SelectColSpanConfig>
    let selectStickyColumnIds: jest.Mock<SelectStickyColumnIds>

    beforeEach(() => {
        selectRow = jest.fn<StoreSimpleSelectors['selectRow']>()
        selectRowMeta = jest
            .fn<StoreSimpleSelectors['selectRowMeta']>()
            .mockReturnValue({})
        selectRowCollection =
            jest.fn<StoreSimpleSelectors['selectRowCollection']>()
        selectRowsExpanded =
            jest.fn<StoreSimpleSelectors['selectRowsExpanded']>()
        selectIsTreeGrid = jest
            .fn<StoreSimpleSelectors['selectIsTreeGrid']>()
            .mockReturnValue(true)
        selectSortFn = jest.fn<SelectSortFn>().mockReturnValue(null)
        selectFilterMatchesShowOnly = jest
            .fn<SelectFilterMatchesShowOnly>()
            .mockReturnValue(null)

        selectColSpanConfig = jest.fn<SelectColSpanConfig>().mockReturnValue({
            colSpanFunctions: [],
            columnIds: [],
        })
        selectStickyColumnIds = jest
            .fn<SelectStickyColumnIds>()
            .mockReturnValue({ left: new Set(), right: new Set() })

        selectHeaderHierarchy = jest
            .fn<StoreSimpleSelectors['selectHeaderHierarchy']>()
            .mockReturnValue({ groups: [], levels: 0 })
        ;({
            selectRowIds,
            selectRowIndex,
            selectAriaRowCount,
            selectAriaSetSize,
            selectAriaPosInset,
            selectColumnSpanByRowId,
        } = generateSelectors(
            {
                selectRowCollection,
                selectRowsExpanded,
                selectIsTreeGrid,
                selectHeaderHierarchy,
                selectRow,
                selectRowMeta,
            },
            selectSortFn as any,
            selectFilterMatchesShowOnly as any,
            selectColSpanConfig as any,
            selectStickyColumnIds as any
        ))

        selectRowsExpanded.mockReturnValue(new Set(['3']))
        selectRowCollection.mockReturnValue({
            ...INITIAL_STATE.rows,
            entities: new Map(
                Object.entries({
                    1: { id: '1' },
                    2: { id: '2' },
                    3: { id: '3' },
                    4: { id: '4' },
                })
            ),
            meta: new Map(
                Object.entries({
                    1: { type: 'tree', children: ['2'] },
                    2: { type: 'leaf' },
                    3: { type: 'tree', children: ['4'] },
                    4: { type: 'leaf' },
                })
            ),
            ids: ['1', '3'],
        })
    })

    describe('selectRowIds', () => {
        it('should return flattened ids', () => {
            expect(selectRowIds(state)).toEqual(['1', '3', '4'])
        })
    })

    describe('selectRowIndex', () => {
        it('should return row index as if list is all expanded', () => {
            expect(selectRowIndex(state, '3')).toEqual(2)
        })
    })

    describe('selectAriaRowCount', () => {
        it('should return row count as if list is all expanded', () => {
            expect(selectAriaRowCount(state)).toEqual(5)
        })
    })

    describe('selectAriaSetSize', () => {
        it('should return set size for a row', () => {
            expect(selectAriaSetSize(state, '1')).toEqual(2)
            expect(selectAriaSetSize(state, '3')).toEqual(2)
        })

        it('should return 0 for a row when not a tree grid', () => {
            selectIsTreeGrid.mockReturnValue(false)
            expect(selectAriaSetSize(state, '1')).toEqual(0)
            expect(selectAriaSetSize(state, '3')).toEqual(0)
        })
    })

    describe('selectAriaPosInset', () => {
        it('should return position inset for a row', () => {
            expect(selectAriaPosInset(state, '1')).toEqual(1)
            expect(selectAriaPosInset(state, '3')).toEqual(2)
        })

        it('should return 0 for a row when not a tree grid', () => {
            selectIsTreeGrid.mockReturnValue(false)
            expect(selectAriaPosInset(state, '1')).toEqual(0)
            expect(selectAriaPosInset(state, '3')).toEqual(0)
        })
    })

    describe('selectColumnSpanByRowId', () => {
        it('should return null when no row is returned', () => {
            selectColSpanConfig.mockReturnValue({
                colSpanFunctions: [
                    { sourceColumn: 'name', colSpan: ['name', 'age'] },
                ],
                columnIds: ['name', 'age', 'rank'],
            })

            expect(selectColumnSpanByRowId(state, '1')).toBeNull()
        })

        it('should return null when there are no colSpanFunctions', () => {
            selectColSpanConfig.mockReturnValue({
                colSpanFunctions: [],
                columnIds: ['name', 'age', 'rank'],
            })
            selectRow.mockReturnValue({ id: '1' })
            expect(selectColumnSpanByRowId(state, '1')).toBeNull()
        })

        it('should return values when there are colSpanFunctions', () => {
            selectColSpanConfig.mockReturnValue({
                colSpanFunctions: [
                    { sourceColumn: 'name', colSpan: ['name', 'age'] },
                ],
                columnIds: ['name', 'age', 'rank'],
            })
            selectRow.mockReturnValue({ id: '1' })
            expect(selectColumnSpanByRowId(state, '1')).toEqual(
                new Map([
                    [
                        'name',
                        {
                            id: 'name',
                            positionColumnIds: ['name', 'age'],
                        },
                    ],
                    ['age', { id: 'age', skip: true }],
                ])
            )
        })
    })
})