aswi2022code-of-duty-gitlab/frontend/src/features/TrackingTool/TrackingTool.tsx @ b70813cb

import { Card, CardContent, Grid, Stack, Typography } from '@mui/material'
import { Fragment, useEffect, useState } from 'react'
import { MapContainer, TileLayer } from 'react-leaflet'
import mapConfig from '../../config/mapConfig'
import TextPath from 'react-leaflet-textpath'
import PlaintextUpload from './PlaintextUpload'
import FileUpload from './FileUpload'
import L from 'leaflet'
import DeleteIcon from '@mui/icons-material/Delete'
import { PathDto } from '../../swagger/data-contracts'
import { formatHtmlStringToReactDom } from '../../utils/formatting/HtmlUtils'
import buildPathVariants, { PathVariant } from './buildPathVariants'
import MapPath from './MapPath'

// Page with tracking tool
const TrackingTool = () => {
    // Path response from the API
    const [pathDto, setPathDto] = useState<PathDto | undefined>(undefined)

    // Whether the path variants are building
    const [buildingPathVariants, setBuildingPathVariants] =
        useState<boolean>(false)

    // List of all computed path variants
    const [pathVariants, setPathVariants] = useState<PathVariant[] | undefined>(
        undefined
    )

    // latitude longitude pair of where the map is to be centered
    const [mapCenter, setMapCenter] = useState<number[]>([
        mapConfig.defaultCoordinates[0],
        mapConfig.defaultCoordinates[1],
    ])

    const [primaryPathIdx, setActivePathIdx] = useState(0)

    // TODO make some sort of selection list to select active paths?
    const [activePaths, setActivePaths] = useState<Set<number>>(new Set())

    // Returns tuple of average latitude and longitude
    const calculateMapCenter = (pathVariant: PathVariant) => [
        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,
    ]

    useEffect(() => {
        if (!pathVariants || pathVariants.length === 0) {
            return
        }
        // TODO calculate only for path that has some non-null coordinates
        setMapCenter(calculateMapCenter(pathVariants[0]))
    }, [pathVariants])

    useEffect(() => {
        if (!pathDto) {
            return
        }

        setBuildingPathVariants(true)
        buildPathVariants(pathDto).then((pathVariants) => {
            setActivePaths(new Set(pathVariants.map((_, idx) => idx)))
            setPathVariants(pathVariants)
            setBuildingPathVariants(false)
        })
    }, [pathDto])

    return (
        <Fragment>
            <Typography variant="h3" sx={{ mb: 2 }} fontWeight="bold">
                Tracking Tool
            </Typography>

            {pathDto && (
                <Fragment>
                    <Card variant="outlined">
                        <CardContent>
                            <Stack direction="column">
                                <Typography
                                    variant="h5"
                                    sx={{ mb: 1 }}
                                    fontWeight="600"
                                >
                                    Processed Text
                                </Typography>
                                <Typography variant="body2">
                                    {formatHtmlStringToReactDom(
                                        pathDto.text ?? ''
                                    )}
                                </Typography>
                            </Stack>
                        </CardContent>
                    </Card>
                </Fragment>
            )}
            <Grid container>
                <Grid item xs={12}>
                    {pathDto && pathDto?.foundCatalogItems?.length === 0 && (
                        <Typography
                            variant="body1"
                            sx={{ mb: 2 }}
                            fontWeight="500"
                            align="center"
                            color="error.main"
                        >
                            Looks like no path / catalog items match this query.
                        </Typography>
                    )}

                    <Stack
                        direction="row"
                        alignItems="flex-start"
                        spacing={2}
                        sx={{ mt: 1 }}
                    >
                        <Typography
                            variant="h5"
                            sx={{ mb: 2 }}
                            fontWeight="500"
                        >
                            {pathDto ? 'Update path' : 'Show Path'}
                        </Typography>
                        <PlaintextUpload setPaths={setPathDto} />
                        <FileUpload />
                    </Stack>
                </Grid>

                <Grid
                    item
                    xs={12}
                    md={12}
                    style={{
                        minHeight: '60vh',
                        maxHeight: '100vh',
                        width: '100%',
                    }}
                >
                    <MapContainer
                        center={[mapCenter[0], mapCenter[1]]}
                        zoom={mapConfig.defaultZoom}
                        style={{ height: '100%', minHeight: '100%' }}
                    >
                        <TileLayer
                            attribution={mapConfig.attribution}
                            url={mapConfig.url}
                        />
                        {pathVariants &&
                            pathVariants.map((pathVariant, idx) => (
                                <MapPath
                                    key={idx}
                                    pathVariant={pathVariant}
                                    idx={idx}
                                    setPrimary={setActivePathIdx}
                                    primaryIdx={primaryPathIdx}
                                    active={activePaths.has(idx)}
                                />
                            ))}
                    </MapContainer>
                </Grid>
            </Grid>
        </Fragment>
    )
}

export default TrackingTool