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

import { createSlice } from '@reduxjs/toolkit'
import { LatLngTuple } from 'leaflet'
import { persistReducer } from 'redux-persist'
import mapConfig from '../../config/mapConfig'
import { PathDto } from '../../swagger/data-contracts'
import buildPathVariants, { PathVariant } from './buildPathVariants'
import { sendTextForProcessing } from './trackingToolThunks'
import storage from 'redux-persist/lib/storage'

export interface TrackingToolState {
    isLoading: boolean // whether the data is being loaded
    pathDto?: PathDto // the data
    pathVariants?: PathVariant[] // undefined signals that no path variants were yet fetched from the API
    lastError?: string // consumable for errors during thunks
    mapCenter: LatLngTuple // pair of latitude and longitude
    primaryPathIdx: number // index of the primary path
    activePaths: Set<number> // indices of the active paths
    // trigger to close the dialog when API call is finished
    dialogApiCallSuccess: boolean
}

const initialState: TrackingToolState = {
    isLoading: false,
    mapCenter: [
        mapConfig.defaultCoordinates[0],
        mapConfig.defaultCoordinates[1],
    ],
    primaryPathIdx: 0,
    activePaths: new Set(),
    dialogApiCallSuccess: true,
}

// Returns tuple of average latitude and longitude
const calculateMapCenter = (pathVariant: PathVariant): LatLngTuple => [
    pathVariant.map((item) => item.latitude ?? 0).reduce((a, b) => a + b, 0) /
        pathVariant.length,
    pathVariant.map((item) => item.longitude ?? 0).reduce((a, b) => a + b, 0) /
        pathVariant.length,
]

const persistConfig = {
    key: 'auth',
    storage, // localStorage for browsers
}

export const trackingToolSlice = createSlice({
    name: 'trackingTool',
    initialState,
    reducers: {
        consumeErr: (state) => ({ ...state, lastErr: undefined }),
        setPrimaryIdx: (state, action) => ({
            ...state,
            primaryPathIdx: action.payload,
        }),
        resetDialogApiCallSuccess: (state) => ({
            ...state,
            dialogApiCallSuccess: false,
        }),
        clear: (state) => ({...initialState})
    },
    extraReducers: (builder) => {
        builder.addCase(sendTextForProcessing.fulfilled, (state, action) => {
            const pathDto: PathDto = action.payload
            const pathVariants = buildPathVariants(pathDto)
            return {
                ...state,
                pathVariants,
                pathDto,
                // TODO map this correctly
                activePaths: new Set(pathVariants.map((_, idx) => idx)),
                // TODO calculate correctly
                mapCenter:
                    pathVariants.length > 0
                        ? calculateMapCenter(pathVariants[0])
                        : (state.mapCenter as LatLngTuple),
                isLoading: false,
                dialogApiCallSuccess: true,
            }
        })
        builder.addCase(sendTextForProcessing.rejected, (state, action) => ({
            ...initialState,
            lastError: action.error.message,
            isLoading: false,
            dialogApiCallSuccess: false,
        }))
        builder.addCase(sendTextForProcessing.pending, (state) => {
            return {
                ...state,
                isLoading: true,
                dialogApiCallSuccess: false,
            }
        })
    },
})

export const { consumeErr, setPrimaryIdx, resetDialogApiCallSuccess, clear } = trackingToolSlice.actions
const trackingToolReducer = trackingToolSlice.reducer
export default trackingToolReducer