import { calculateColumnMoving, calculateGroupMoving } from './utils'
import type { ColumnState, HeaderHierarchy } from '../../../state'
describe('utils', () => {
    describe('calculateColumnMoving', () => {
        const groupEntities: Record<string, ColumnState> = {
            group1: {
                id: 'group1',
                actualWidth: 200,
                data: {
                    lockedLocation: 'none',
                    id: 'group1',
                    label: 'Group 1',
                },
                parentId: undefined,
            },
            group2: {
                id: 'group2',
                actualWidth: 100,
                data: {
                    lockedLocation: 'none',
                    id: 'group2',
                    label: 'Group 2',
                },
                parentId: undefined,
            },
        }

        const columns: ColumnState[] = [
            {
                id: 'col1',
                actualWidth: 100,
                data: { lockedLocation: 'none', id: 'col1', label: 'Column 1' },
                parentId: 'group1',
            },
            {
                id: 'col2',
                actualWidth: 100,
                data: { lockedLocation: 'none', id: 'col2', label: 'Column 2' },
                parentId: 'group1',
            },
            {
                id: 'col3',
                actualWidth: 100,
                data: { lockedLocation: 'none', id: 'col3', label: 'Column 3' },
                parentId: 'group2',
            },
        ]

        const groups: HeaderHierarchy['groups'] = [
            {
                id: 'group1',
                childIds: ['col1', 'col2'],
                width: 2,
                level: 1,
                columnIds: ['col1', 'col2'],
                parentIds: [],
            },
            {
                id: 'group2',
                childIds: ['col3'],
                width: 1,
                level: 1,
                columnIds: ['col3'],
                parentIds: [],
            },
        ]

        const getGroup = (id: string) => groupEntities[id]

        it('should calculate column moving bounds and locations correctly', () => {
            const result = calculateColumnMoving(
                'col2',
                columns,
                groups,
                getGroup,
                []
            )

            expect(result).toEqual({
                locations: [
                    {
                        location: 50,
                        newIndex: 0,
                        compare: 'less',
                        parentId: null,
                    },
                    {
                        location: 150,
                        newIndex: 2,
                        compare: 'more',
                        parentId: 'group2',
                    },
                ],
                initialLeft: 100,
                currentIndex: 1,
                minIndex: 0,
                maxIndex: 1,
                minLeft: -100,
                maxLeft: 0,
            })
        })

        it('should handle columns with locked locations', () => {
            const columnsWithLocked: ColumnState[] = [
                {
                    id: 'col1',
                    actualWidth: 100,
                    data: {
                        lockedLocation: 'left',
                        id: 'col1',
                        label: 'Column 1',
                    },
                    parentId: 'group1',
                },
                {
                    id: 'col2',
                    actualWidth: 100,
                    data: { id: 'col2', label: 'Column 2' },
                    parentId: 'group1',
                },
                {
                    id: 'col3',
                    actualWidth: 100,
                    data: {
                        lockedLocation: 'right',
                        id: 'col3',
                        label: 'Column 3',
                    },
                    parentId: 'group2',
                },
            ]

            const result = calculateColumnMoving(
                'col2',
                columnsWithLocked,
                groups,
                getGroup,
                []
            )

            expect(result).toEqual({
                locations: [
                    {
                        location: 150,
                        newIndex: 2,
                        compare: 'more',
                        parentId: 'group2',
                    },
                ],
                initialLeft: 100,
                currentIndex: 1,
                minIndex: 1,
                maxIndex: 1,
                minLeft: 0,
                maxLeft: 100,
            })
        })

        it('should handle columns with parents', () => {
            const columnsWithParents: ColumnState[] = [
                {
                    id: 'col1',
                    actualWidth: 100,
                    data: {
                        lockedLocation: undefined,
                        id: 'col1',
                        label: 'Column 1',
                    },
                    parentId: 'group1',
                },
                {
                    id: 'col2',
                    actualWidth: 100,
                    data: {
                        lockedLocation: undefined,
                        id: 'col2',
                        label: 'Column 2',
                    },
                    parentId: 'group1',
                },
                {
                    id: 'col3',
                    actualWidth: 100,
                    data: {
                        lockedLocation: undefined,
                        id: 'col3',
                        label: 'Column 3',
                    },
                    parentId: 'group2',
                },
            ]

            const result = calculateColumnMoving(
                'col2',
                columnsWithParents,
                groups,
                getGroup,
                []
            )

            expect(result).toEqual({
                locations: [
                    {
                        location: 50,
                        newIndex: 0,
                        compare: 'less',
                        parentId: null,
                    },
                    {
                        location: 150,
                        newIndex: 2,
                        compare: 'more',
                        parentId: 'group2',
                    },
                ],
                initialLeft: 100,
                currentIndex: 1,
                minIndex: 0,
                maxIndex: 1,
                minLeft: -100,
                maxLeft: 0,
            })
        })

        it('should handle columns with no parent', () => {
            const columnsWithoutParents: ColumnState[] = [
                {
                    id: 'col1',
                    actualWidth: 100,
                    data: {
                        lockedLocation: 'none',
                        id: 'col1',
                        label: 'Column 1',
                    },
                    parentId: undefined,
                },
                {
                    id: 'col2',
                    actualWidth: 100,
                    data: {
                        lockedLocation: 'none',
                        id: 'col2',
                        label: 'Column 2',
                    },
                    parentId: undefined,
                },
                {
                    id: 'col3',
                    actualWidth: 100,
                    data: {
                        lockedLocation: 'none',
                        id: 'col3',
                        label: 'Column 3',
                    },
                    parentId: undefined,
                },
            ]

            const result = calculateColumnMoving(
                'col2',
                columnsWithoutParents,
                [],
                getGroup,
                []
            )

            expect(result).toEqual({
                locations: [
                    {
                        location: 50,
                        newIndex: 0,
                        compare: 'less',
                        parentId: null,
                    },
                    {
                        location: 150,
                        newIndex: 2,
                        compare: 'more',
                        parentId: null,
                    },
                ],
                initialLeft: 100,
                currentIndex: 1,
                minIndex: 0,
                maxIndex: Infinity,
                minLeft: -100,
                maxLeft: 100,
            })
        })

        it('should handle columns with mixed locked locations', () => {
            const columnsWithMixedLocked: ColumnState[] = [
                {
                    id: 'col1',
                    actualWidth: 100,
                    data: {
                        lockedLocation: 'left',
                        id: 'col1',
                        label: 'Column 1',
                    },
                    parentId: 'group1',
                },
                {
                    id: 'col2',
                    actualWidth: 100,
                    data: {
                        lockedLocation: 'none',
                        id: 'col2',
                        label: 'Column 2',
                    },
                    parentId: 'group1',
                },
                {
                    id: 'col3',
                    actualWidth: 100,
                    data: {
                        lockedLocation: 'right',
                        id: 'col3',
                        label: 'Column 3',
                    },
                    parentId: 'group2',
                },
            ]

            const result = calculateColumnMoving(
                'col2',
                columnsWithMixedLocked,
                groups,
                getGroup,
                []
            )

            expect(result).toEqual({
                locations: [
                    {
                        location: 150,
                        newIndex: 2,
                        compare: 'more',
                        parentId: 'group2',
                    },
                ],
                initialLeft: 100,
                currentIndex: 1,
                minIndex: 1,
                maxIndex: 1,
                minLeft: 0,
                maxLeft: 100,
            })
        })
        describe('hidden columns', () => {
            describe('no groups', () => {
                it('should not include hidden columns in the moving locations', () => {
                    const columnsWithHidden: ColumnState[] = [
                        {
                            id: 'col1',
                            actualWidth: 100,
                            data: {
                                lockedLocation: 'none',
                                id: 'col1',
                                label: 'Column 1',
                            },
                            parentId: null,
                        },
                        {
                            id: 'col2',
                            actualWidth: 100,
                            data: {
                                lockedLocation: 'none',
                                id: 'col2',
                                label: 'Column 2',
                            },
                            parentId: null,
                        },
                        {
                            id: 'col3',
                            actualWidth: 200,
                            data: {
                                hidden: true,
                                lockedLocation: 'none',
                                id: 'col3',
                                label: 'Column 3',
                            },
                            parentId: null,
                        },
                        {
                            id: 'col4',
                            actualWidth: 100,
                            data: {
                                lockedLocation: 'none',
                                id: 'col4',
                                label: 'Column 4',
                            },
                            parentId: null,
                        },
                        {
                            id: 'col5',
                            actualWidth: 400,
                            data: {
                                hidden: true,
                                lockedLocation: 'none',
                                id: 'col5',
                                label: 'Column 5',
                            },
                            parentId: null,
                        },
                    ]

                    const result = calculateColumnMoving(
                        'col2',
                        columnsWithHidden,
                        [],
                        getGroup,
                        ['col3', 'col5']
                    )

                    expect(result).toEqual({
                        locations: [
                            {
                                location: 50,
                                newIndex: 0,
                                compare: 'less',
                                parentId: null,
                            },
                            {
                                location: 150,
                                newIndex: 3,
                                compare: 'more',
                                parentId: null,
                            },
                        ],
                        initialLeft: 100,
                        currentIndex: 1,
                        minIndex: 0,
                        maxIndex: Infinity,
                        minLeft: -100,
                        maxLeft: 100,
                    })
                })
            })
            describe('with groups', () => {
                const groupEntities: Record<string, ColumnState> = {
                    group1: {
                        id: 'group1',
                        actualWidth: 200,
                        data: {
                            lockedLocation: 'none',
                            id: 'group1',
                            label: 'Group 1',
                        },
                        parentId: undefined,
                    },
                }
                const groups: HeaderHierarchy['groups'] = [
                    {
                        id: 'group1',
                        childIds: ['col1', 'col2'],
                        width: 2,
                        level: 1,
                        columnIds: ['col1', 'col2'],
                        parentIds: [],
                    },
                ]
                const getGroup = (id: string) => groupEntities[id]
                it('should not include hidden columns in the moving locations', () => {
                    const columnsWithHidden: ColumnState[] = [
                        {
                            id: 'col1',
                            actualWidth: 100,
                            data: {
                                hidden: true,
                                lockedLocation: 'none',
                                id: 'col1',
                                label: 'Column 1',
                            },
                            parentId: 'group1',
                        },
                        {
                            id: 'col2',
                            actualWidth: 100,
                            data: {
                                lockedLocation: 'none',
                                id: 'col2',
                                label: 'Column 2',
                            },
                            parentId: 'group1',
                        },
                        {
                            id: 'col3',
                            actualWidth: 200,
                            data: {
                                hidden: true,
                                lockedLocation: 'none',
                                id: 'col3',
                                label: 'Column 3',
                            },
                            parentId: null,
                        },
                        {
                            id: 'col4',
                            actualWidth: 100,
                            data: {
                                lockedLocation: 'none',
                                id: 'col4',
                                label: 'Column 4',
                            },
                            parentId: null,
                        },
                        {
                            id: 'col5',
                            actualWidth: 400,
                            data: {
                                hidden: true,
                                lockedLocation: 'none',
                                id: 'col5',
                                label: 'Column 5',
                            },
                            parentId: null,
                        },
                    ]

                    const result = calculateColumnMoving(
                        'col3',
                        columnsWithHidden,
                        groups,
                        getGroup,
                        ['col1', 'col3', 'col5']
                    )

                    expect(result).toEqual({
                        locations: [
                            {
                                location: 100,
                                newIndex: 1,
                                compare: 'less',
                                parentId: 'group1',
                            },
                            {
                                location: 150,
                                newIndex: 3,
                                compare: 'more',
                                parentId: null,
                            },
                        ],
                        initialLeft: 100,
                        currentIndex: 2,
                        minIndex: 0,
                        maxIndex: Infinity,
                        minLeft: -100,
                        maxLeft: 100,
                    })
                })
            })
        })
    })
    describe('calculateGroupMoving', () => {
        const groupEntities: Record<string, ColumnState> = {
            group0: {
                id: 'group0',
                actualWidth: 300,
                data: {
                    lockedLocation: 'none',
                    id: 'group1',
                    label: 'Group 1',
                },
                parentId: undefined,
            },
            group1: {
                id: 'group1',
                actualWidth: 200,
                data: {
                    lockedLocation: 'none',
                    id: 'group1',
                    label: 'Group 1',
                },
                parentId: 'group0',
            },
            group2: {
                id: 'group2',
                actualWidth: 100,
                data: {
                    lockedLocation: 'none',
                    id: 'group2',
                    label: 'Group 2',
                },
                parentId: 'group0',
            },
        }

        const columns: ColumnState[] = [
            {
                id: 'col1',
                actualWidth: 100,
                data: { lockedLocation: 'none', id: 'col1', label: 'Column 1' },
                parentId: 'group1',
            },
            {
                id: 'col2',
                actualWidth: 100,
                data: { lockedLocation: 'none', id: 'col2', label: 'Column 2' },
                parentId: 'group1',
            },
            {
                id: 'col3',
                actualWidth: 100,
                data: { lockedLocation: 'none', id: 'col3', label: 'Column 3' },
                parentId: 'group2',
            },
        ]

        const groups: HeaderHierarchy['groups'] = [
            {
                id: 'group0',
                childIds: ['group1', 'group2'],
                width: 3,
                level: 2,
                columnIds: ['col1', 'col2', 'col3'],
                parentIds: [],
            },
            {
                id: 'group1',
                childIds: ['col1', 'col2'],
                width: 2,
                level: 1,
                columnIds: ['col1', 'col2'],
                parentIds: ['group0'],
            },
            {
                id: 'group2',
                childIds: ['col3'],
                width: 1,
                level: 1,
                columnIds: ['col3'],
                parentIds: ['group0'],
            },
        ]

        const getGroup = (id: string) => groupEntities[id]
        it('should calculate group moving bounds and locations correctly', () => {
            const result = calculateGroupMoving(
                'group1',
                columns,
                groups,
                getGroup,
                []
            )

            expect(result).toEqual({
                locations: [
                    {
                        location: 150,
                        newIndex: 2,
                        compare: 'more',
                        parentId: 'group2',
                    },
                ],
                initialLeft: 0,
                currentIndex: 0,
                minIndex: 0,
                maxIndex: 2,
                minLeft: 0,
                maxLeft: 100,
            })
        })
        describe('with hidden columns', () => {
            const groupEntities: Record<string, ColumnState> = {
                group0: {
                    id: 'group0',
                    actualWidth: 300,
                    data: {
                        lockedLocation: 'none',
                        id: 'group1',
                        label: 'Group 1',
                    },
                    parentId: null,
                },
                group1: {
                    id: 'group1',
                    actualWidth: 200,
                    data: {
                        lockedLocation: 'none',
                        id: 'group1',
                        label: 'Group 1',
                    },
                    parentId: 'group0',
                },
                group2: {
                    id: 'group2',
                    actualWidth: 100,
                    data: {
                        lockedLocation: 'none',
                        id: 'group2',
                        label: 'Group 2',
                    },
                    parentId: 'group0',
                },
            }

            const columns: ColumnState[] = [
                {
                    id: 'col0',
                    actualWidth: 100,
                    data: {
                        lockedLocation: 'none',
                        id: 'col0',
                        label: 'Column 1',
                    },
                    parentId: null,
                },
                {
                    id: 'col1',
                    actualWidth: 100,
                    data: {
                        hidden: true,
                        lockedLocation: 'none',
                        id: 'col1',
                        label: 'Column 1',
                    },
                    parentId: 'group1',
                },
                {
                    id: 'col2',
                    actualWidth: 100,
                    data: {
                        hidden: true,
                        lockedLocation: 'none',
                        id: 'col2',
                        label: 'Column 2',
                    },
                    parentId: 'group1',
                },
                {
                    id: 'col3',
                    actualWidth: 100,
                    data: {
                        lockedLocation: 'none',
                        id: 'col3',
                        label: 'Column 3',
                    },
                    parentId: 'group2',
                },
            ]

            const groups: HeaderHierarchy['groups'] = [
                {
                    id: 'group0',
                    childIds: ['group1', 'group2'],
                    width: 3,
                    level: 2,
                    columnIds: ['col1', 'col2', 'col3'],
                    parentIds: [],
                },
                {
                    id: 'group1',
                    childIds: ['col1', 'col2'],
                    width: 2,
                    level: 1,
                    columnIds: ['col1', 'col2'],
                    parentIds: ['group0'],
                },
                {
                    id: 'group2',
                    childIds: ['col3'],
                    width: 1,
                    level: 1,
                    columnIds: ['col3'],
                    parentIds: ['group0'],
                },
            ]

            const getGroup = (id: string) => groupEntities[id]
            it('should calculate group moving bounds and locations correctly when there are no locations due to hidden columns in group', () => {
                const result = calculateGroupMoving(
                    'group2',
                    columns,
                    groups,
                    getGroup,
                    columns
                        .filter((column) => column.data.hidden)
                        .map((column) => column.id)
                )

                expect(result).toEqual({
                    locations: [],
                    initialLeft: 100,
                    currentIndex: 3,
                    minIndex: 1,
                    maxIndex: 3,
                    minLeft: 0,
                    maxLeft: 200,
                })
            })
            it('should calculate group moving bounds and locations correctly when there are locations', () => {
                const result = calculateGroupMoving(
                    'group0',
                    columns,
                    groups,
                    getGroup,
                    columns
                        .filter((column) => column.data.hidden)
                        .map((column) => column.id)
                )

                expect(result).toEqual({
                    locations: [
                        {
                            location: 50,
                            newIndex: 0,
                            compare: 'less',
                            parentId: null,
                        },
                    ],
                    initialLeft: 100,
                    currentIndex: 1,
                    minIndex: 0,
                    maxIndex: 3,
                    minLeft: -100,
                    maxLeft: 0,
                })
            })
        })
    })
})