aswi2022code-of-duty-gitlab/frontend/src/features/TrackingTool/trackingToolSlice.ts @ 48690561

import { createSlice } from '@reduxjs/toolkit'
import mapConfig from '../../config/mapConfig'
import { PathDto } from '../../swagger/data-contracts'
import buildPathVariants from './Map/mapUtils'
import TrackingToolState from './trackingToolState'
import { sendTextForProcessing } from './trackingToolThunks'
import { calculateMapCenter, MapPoint, PathVariant } from './trackingToolUtils'

const initialState: TrackingToolState = {
    isLoading: false,
    mapCenter: [mapConfig.defaultCoordinates[0], mapConfig.defaultCoordinates[1]],
    displayedPathIdx: 0,
    dialogApiCallSuccess: true,
}

export const trackingToolSlice = createSlice({
    name: 'trackingTool',
    initialState,
    reducers: {
        consumeErr: (state: TrackingToolState) => ({ ...state, lastErr: undefined, }),
        setSelectedPathIdx: (state: TrackingToolState, action: { payload: number }) => ({ ...state, selectedPathIdx: action.payload, }),
        resetDialogApiCallSuccess: (state: TrackingToolState) => ({ ...state, dialogApiCallSuccess: false, }),
        // Updates currently displayed path
        updateDisplayedPath: (state: TrackingToolState, action: { payload: PathVariant }) => ({ ...state, displayedPath: action.payload, }),
        // Updates map marker
        updateMapMarker: (state: TrackingToolState, action: { payload: MapPoint }) => {
            const newPath = [...state.displayedPath ?? []]
            if (newPath.length <= action.payload.idx) {
                return state // do nothing if there is no path
            }

            newPath[action.payload.idx] = action.payload
            return {
                ...state,
                displayedPath: newPath,
            }
        },
        // Removes map marker from currently used path
        removeMapMarker: (state: TrackingToolState, action: { payload: { id: string, idx: number } }) => {
            const newPath = [...state.displayedPath ?? []]
            if (newPath.length <= action.payload.idx) {
                return state // do nothing if there is no path
            }

            return {
                ...state,
                displayedPath: [...newPath.slice(0, action.payload.idx), ...newPath.slice(action.payload.idx + 1)],
            }
        },
        // Moves map marker in the path array
        moveMarkerToDestination: (state: TrackingToolState, action: { payload: { destination: number, source: number } }) => {
            const { destination, source } = action.payload
            const newPath = [...state.displayedPath ?? []]
            if (newPath.length <= source
                || newPath.length <= destination
                || source === destination) {
                return state // do nothing if there is no path
            }

            // JS array dark magic
            const [removed] = newPath.splice(action.payload.source, 1)
            newPath.splice(destination, 0, removed)
            return {
                ...state,
                displayedPath: newPath.map((item, idx) => ({ ...item, idx })),
            }
        },
        clear: () => ({ ...initialState }),
        mergeWithCurrentPath: (state: TrackingToolState, action: { payload: PathVariant }) => {
            const { payload: jsonPath } = action
            if (!jsonPath) {
                return state
            }

            const newPath = [...state.displayedPath ?? []]
            const existingIds = new Set(newPath.map(item => item.id ?? ''))

            const newItems: MapPoint[] = []
            jsonPath.forEach(item => {
                if (!existingIds.has(item.id ?? '')) {
                    newItems.push(item)
                }
            })

            newItems.forEach(item => {
                item.addToPath = !state.pathVariants || state.pathVariants.length === 0
                item.idx = newPath.length
                newPath.push(item)
            })

            return {
                ...state,
                displayedPath: newPath,
            }
        },
    },
    extraReducers: (builder) => {
        builder.addCase(sendTextForProcessing.fulfilled, (state, action) => {
            const pathDto: PathDto = action.payload
            const pathVariants = buildPathVariants(pathDto)
            const selectedPath = pathVariants.length > 0 ? pathVariants[0] : undefined
            if (!selectedPath) {
                return {
                    ...state,
                    pathDto,
                    pathVariants,
                    displayedPath: undefined,
                    displayedPathIdx: 0,
                    dialogApiCallSuccess: true,
                    isLoading: false,
                }
            }

            const mapCenter = calculateMapCenter(selectedPath)
            return {
                ...state,
                pathVariants,
                pathDto,
                mapCenter: mapCenter ?? state.mapCenter,
                isLoading: false,
                dialogApiCallSuccess: true,
                currentPage: 0,
                displayedPath: selectedPath,
                displayedPathIdx: 0,
            }
        })
        builder.addCase(sendTextForProcessing.rejected, (_, action) => ({
            ...initialState,
            lastError: action.error.message,
            isLoading: false,
            dialogApiCallSuccess: false,
            currentPage: 0,
            displayedPath: undefined,
            displayedPathIdx: 0,
            pathDto: undefined,
            pathVariants: undefined,
        }))
        builder.addCase(sendTextForProcessing.pending, (state) => ({
            ...state,
            isLoading: true,
            dialogApiCallSuccess: false,
        }))
    }
})

export const {
    consumeErr,
    setSelectedPathIdx,
    resetDialogApiCallSuccess,
    updateDisplayedPath,
    updateMapMarker,
    removeMapMarker,
    moveMarkerToDestination,
    clear,
    mergeWithCurrentPath,
} = trackingToolSlice.actions

const trackingToolReducer = trackingToolSlice.reducer
export default trackingToolReducer