import type { GridState } from '..'
import { jest } from '@jest/globals'
import type { StoreSimpleSelectors } from '../selectors'
import type { SelectBorderLayout } from './column'
import generateSelectors from './column'
import { ACTIONS_COLUMN_ID, SELECTION_COLUMN_ID } from '../../constants'

describe('compositeSelectors - column', () => {
    let selectBorderLayout: SelectBorderLayout
    let selectColumnEntities: StoreSimpleSelectors['selectColumnEntities']
    let selectColumnIdsWithHidden: StoreSimpleSelectors['selectColumnIdsWithHidden']
    let selectHiddenIds: StoreSimpleSelectors['selectHiddenIds']
    let selectIsSpreadsheet: StoreSimpleSelectors['selectIsSpreadsheet']

    beforeEach(() => {
        selectColumnEntities =
            jest.fn<StoreSimpleSelectors['selectColumnEntities']>()
        selectColumnIdsWithHidden =
            jest.fn<StoreSimpleSelectors['selectColumnIdsWithHidden']>()
        selectHiddenIds = jest.fn<StoreSimpleSelectors['selectHiddenIds']>()
        selectIsSpreadsheet = jest
            .fn<StoreSimpleSelectors['selectIsSpreadsheet']>()
            .mockReturnValue(false)
        ;({ selectBorderLayout } = generateSelectors({
            selectColumnIdsWithHidden,
            selectColumnEntities,
            selectHiddenIds,
            selectIsSpreadsheet,
        }))
    })

    describe('selectStickyColumnIds', () => {
        it('should return sticky columns for left and right', () => {
            jest.mocked(selectColumnEntities).mockReturnValue({
                '1': {
                    id: '1',
                    actualWidth: 100,
                    data: { id: '1', label: 'Title', sticky: 'left' },
                },
                '2': {
                    id: '2',
                    actualWidth: 100,
                    data: { id: '2', label: 'Price', sticky: 'right' },
                },
                '3': {
                    id: '3',
                    actualWidth: 100,
                    data: { id: '3', label: 'Discount' },
                },
            })
            const { selectStickyColumnIds } = generateSelectors({
                selectColumnIdsWithHidden,
                selectColumnEntities,
                selectHiddenIds,
                selectIsSpreadsheet,
            })
            const res = selectStickyColumnIds({} as GridState)

            expect(res).toEqual({
                left: new Set(['1']),
                right: new Set(['2']),
            })
        })

        it('should return empty sets when no sticky columns are defined', () => {
            jest.mocked(selectColumnEntities).mockReturnValue({
                '1': {
                    id: '1',
                    actualWidth: 100,
                    data: { id: '1', label: 'Title' },
                },
                '2': {
                    id: '2',
                    actualWidth: 100,
                    data: { id: '2', label: 'Price' },
                },
                '3': {
                    id: '3',
                    actualWidth: 100,
                    data: { id: '3', label: 'Discount' },
                },
            })
            const { selectStickyColumnIds } = generateSelectors({
                selectColumnIdsWithHidden,
                selectColumnEntities,
                selectHiddenIds,
                selectIsSpreadsheet,
            })
            const res = selectStickyColumnIds({} as GridState)

            expect(res).toEqual({
                left: new Set(),
                right: new Set(),
            })
        })
    })

    describe('selectColSpanConfig', () => {
        beforeEach(() => {
            jest.mocked(selectColumnEntities).mockReturnValue({
                title: {
                    id: 'title',
                    actualWidth: 100,
                    data: {
                        id: 'title',
                        label: 'Title',
                        cell: { colSpan: ['title', 'price'] },
                    },
                },
                price: {
                    id: 'price',
                    actualWidth: 100,
                    data: { id: 'price', label: 'Price' },
                },
                discount: {
                    id: 'discount',
                    actualWidth: 100,
                    data: {
                        id: 'discount',
                        label: 'Discount',
                        cell: { colSpan: () => ['discount', 'total'] },
                    },
                },
                total: {
                    id: 'total',
                    actualWidth: 200,
                    data: { id: 'total', label: 'Total' },
                },
            })
            jest.mocked(selectColumnIdsWithHidden).mockReturnValue([
                SELECTION_COLUMN_ID,
                'title',
                'price',
                'discount',
                'total',
                ACTIONS_COLUMN_ID,
            ])
            jest.mocked(selectHiddenIds).mockReturnValue([])
        })
        it('should return colSpan configuration and ids', () => {
            const { selectColSpanConfig } = generateSelectors({
                selectColumnIdsWithHidden,
                selectColumnEntities,
                selectHiddenIds,
                selectIsSpreadsheet,
            })
            const res = selectColSpanConfig({} as GridState)

            expect(res).toEqual({
                colSpanFunctions: [
                    { sourceColumn: 'title', colSpan: ['title', 'price'] },
                    { sourceColumn: 'discount', colSpan: expect.any(Function) },
                ],
                columnIds: ['title', 'price', 'discount', 'total'],
            })
        })

        it('should exclude hidden columns from columnIds', () => {
            jest.mocked(selectHiddenIds).mockReturnValue(['price', 'total'])
            const { selectColSpanConfig } = generateSelectors({
                selectColumnIdsWithHidden,
                selectColumnEntities,
                selectHiddenIds,
                selectIsSpreadsheet,
            })
            const res = selectColSpanConfig({} as GridState)

            expect(res).toEqual({
                colSpanFunctions: [
                    { sourceColumn: 'title', colSpan: ['title', 'price'] },
                    { sourceColumn: 'discount', colSpan: expect.any(Function) },
                ],
                columnIds: ['title', 'discount'],
            })
        })
    })

    describe('selectBorderLayout', () => {
        it('should return a comprehensive border layout (spreadsheet mode)', () => {
            jest.mocked(selectColumnEntities).mockReturnValue({
                '1': {
                    id: '1',
                    actualWidth: 100,
                    data: { id: '1', label: 'Title', border: 'left' },
                },
                '2': {
                    id: '2',
                    actualWidth: 100,
                    data: { id: '2', label: 'Price', border: 'right' },
                },
                '3': {
                    id: '3',
                    actualWidth: 100,
                    data: { id: '3', label: 'Discount', border: 'right' },
                },
            })
            jest.mocked(selectColumnIdsWithHidden).mockReturnValue([
                '3',
                '1',
                '2',
            ])
            jest.mocked(selectIsSpreadsheet).mockReturnValue(true)
            jest.mocked(selectHiddenIds).mockReturnValue([])
            const res = selectBorderLayout({} as GridState)

            expect(res).toEqual(
                new Map([
                    [
                        '1',
                        {
                            header: { left: false, right: true },
                            body: { left: false, right: true },
                            footer: { left: false, right: true },
                        },
                    ],
                    [
                        '2',
                        {
                            header: { left: false, right: true },
                            body: { left: false, right: true },
                            footer: { left: false, right: true },
                        },
                    ],
                    [
                        '3',
                        {
                            header: { left: true, right: true },
                            body: { left: true, right: true },
                            footer: { left: true, right: true },
                        },
                    ],
                ])
            )
        })

        it('should return a comprehensive border layout (one row of headers)', () => {
            jest.mocked(selectColumnEntities).mockReturnValue({
                '1': {
                    id: '1',
                    actualWidth: 100,
                    data: { id: '1', label: 'Title', border: 'left' },
                },
                '2': {
                    id: '2',
                    actualWidth: 100,
                    data: { id: '2', label: 'Price', border: 'right' },
                },
                '3': {
                    id: '3',
                    actualWidth: 100,
                    data: { id: '3', label: 'Discount', border: 'right' },
                },
            })
            jest.mocked(selectColumnIdsWithHidden).mockReturnValue([
                '3',
                '1',
                '2',
            ])
            jest.mocked(selectHiddenIds).mockReturnValue([])
            const res = selectBorderLayout({} as GridState)

            expect(res).toEqual(
                new Map([
                    [
                        '1',
                        {
                            header: { left: false, right: false },
                            body: { left: false, right: false },
                            footer: { left: false, right: false },
                        },
                    ],
                    [
                        '2',
                        {
                            header: { left: false, right: true },
                            body: { left: false, right: true },
                            footer: { left: false, right: true },
                        },
                    ],
                    [
                        '3',
                        {
                            header: { left: false, right: true },
                            body: { left: false, right: true },
                            footer: { left: false, right: true },
                        },
                    ],
                ])
            )
        })

        it('should return a comprehensive border layout (two rows of headers)', () => {
            jest.mocked(selectColumnEntities).mockReturnValue({
                '1': {
                    id: '1',
                    actualWidth: 100,
                    data: { id: '1', label: 'Title' },
                },
                '2': {
                    id: '2',
                    actualWidth: 100,
                    data: { id: '2', label: 'Price' },
                    parentId: '4',
                },
                '3': {
                    id: '3',
                    actualWidth: 100,
                    data: { id: '3', label: 'Discount' },
                    parentId: '4',
                },
                '4': {
                    id: '4',
                    actualWidth: 200,
                    childIds: ['2', '3'],
                    data: { id: '4', label: 'Group', border: 'both' },
                },
            })
            jest.mocked(selectColumnIdsWithHidden).mockReturnValue([
                '1',
                '3',
                '2',
            ])
            jest.mocked(selectHiddenIds).mockReturnValue([])
            const res = selectBorderLayout({} as GridState)

            expect(res).toEqual(
                new Map([
                    [
                        '1',
                        {
                            header: { left: false, right: true },
                            body: { left: false, right: true },
                            footer: { left: false, right: true },
                        },
                    ],
                    [
                        '2',
                        {
                            header: { left: false, right: true },
                            body: { left: false, right: true },
                            footer: { left: false, right: true },
                        },
                    ],
                    [
                        '3',
                        {
                            header: { left: false, right: false },
                            body: { left: false, right: false },
                            footer: { left: false, right: false },
                        },
                    ],
                ])
            )
        })

        it('should return a comprehensive border layout (three rows of headers)', () => {
            jest.mocked(selectColumnEntities).mockReturnValue({
                '1': {
                    id: '1',
                    actualWidth: 100,
                    data: { id: '1', label: 'Title' },
                    parentId: '5',
                },
                '2': {
                    id: '2',
                    actualWidth: 100,
                    data: { id: '2', label: 'Price' },
                    parentId: '4',
                },
                '3': {
                    id: '3',
                    actualWidth: 100,
                    data: { id: '3', label: 'Discount' },
                    parentId: '4',
                },
                '4': {
                    id: '4',
                    actualWidth: 200,
                    childIds: ['2', '3'],
                    data: { id: '4', label: 'Group', border: 'both' },
                    parentId: '5',
                },
                '5': {
                    id: '5',
                    actualWidth: 300,
                    data: { id: '5', label: 'All', border: 'both' },
                    childIds: ['1', '4'],
                },
            })
            jest.mocked(selectColumnIdsWithHidden).mockReturnValue([
                '1',
                '3',
                '2',
            ])
            jest.mocked(selectHiddenIds).mockReturnValue([])
            const res = selectBorderLayout({} as GridState)
            jest.mocked(selectHiddenIds).mockReturnValue([])
            expect(res).toEqual(
                new Map([
                    [
                        '1',
                        {
                            header: { left: true, right: true },
                            body: { left: true, right: true },
                            footer: { left: true, right: true },
                        },
                    ],
                    [
                        '2',
                        {
                            header: { left: false, right: true },
                            body: { left: false, right: true },
                            footer: { left: false, right: true },
                        },
                    ],
                    [
                        '3',
                        {
                            header: { left: false, right: false },
                            body: { left: false, right: false },
                            footer: { left: false, right: false },
                        },
                    ],
                ])
            )
        })
    })
})