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

import { createSlice } from '@reduxjs/toolkit'
import mapConfig from '../../config/mapConfig'
import { PathDto } from '../../swagger/data-contracts'
import generateUuid from '../../utils/id/uuidGenerator'
import buildPathVariants from './Map/mapUtils'
import TrackingToolState from './trackingToolState'
import { sendTextForProcessing } from './trackingToolThunks'
import { calculateMapCenter, MapPoint, PathVariant, setMapPointIds } 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, }),
        updateMapPointAtIndex: (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,
            }
        },
        // Updates map marker
        updateMapPoint: (state: TrackingToolState, action: { payload: MapPoint }) => {
            const newPath = [...state.displayedPath ?? []]
            return {
                ...state,
                displayedPath: newPath.map((point, _) => point.id === action.payload.id ? {...action.payload, idx: point.idx} : point)
            }
        },
        // 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)],
            }
        },
        // Changes marker index
        changeMarkerIdx: (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
                const uuid = generateUuid()
                item.reactId = uuid
                item.id = item.catalogItem.id ? item.catalogItem.id : uuid
                newPath.push(item)
            })

            return {
                ...state,
                displayedPath: newPath,
            }
        },
        // Updates currently used path - payload must be a number indexed from 1 since this is default behavior
        // for MUI Pagination
        // This function should only ever be called if there is some displayed path
        setDisplayedPathIdx: (state: TrackingToolState, action: { payload: number }) => {
            const newIdx = action.payload - 1 // subtract one to make index start from 0
            const pathVariants = [...state.pathVariants ?? []]
            const previousIdx = state.displayedPathIdx
            if (pathVariants.length < newIdx || newIdx < 0) {
                return state
            }

            // We will always have displayedPath defined if this function is called
            pathVariants.splice(previousIdx, 0, [...state.displayedPath ?? []])
            const newPath = setMapPointIds(pathVariants.splice(newIdx, 1)[0])
            return {
                ...state,
                displayedPath: newPath,
                displayedPathIdx: newIdx,
                pathVariants,
            }
        },
    },
    extraReducers: (builder) => {
        builder.addCase(sendTextForProcessing.fulfilled, (state, action) => {
            const pathDto: PathDto = action.payload
            const pathVariants = buildPathVariants(pathDto)
            const selectedPath = pathVariants.length > 0 ? setMapPointIds(pathVariants[0]) : undefined
            pathVariants.splice(0, 1) // remove the selected path so that we do not have to update it here
            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,
    updateMapPoint,
    removeMapMarker,
    changeMarkerIdx,
    clear,
    mergeWithCurrentPath,
    setDisplayedPathIdx,
    updateMapPointAtIndex
} = trackingToolSlice.actions

const trackingToolReducer = trackingToolSlice.reducer
export default trackingToolReducer