MapComplete/Logic/Osm/Actions/ReplaceGeometryAction.ts

import OsmChangeAction from "./OsmChangeAction"
import { Changes } from "../Changes"
import { ChangeDescription } from "./ChangeDescription"
import { Tag } from "../../Tags/Tag"
import FeatureSource from "../../FeatureSource/FeatureSource"
import { OsmNode, OsmObject, OsmWay } from "../OsmObject"
import { GeoOperations } from "../../GeoOperations"
import StaticFeatureSource from "../../FeatureSource/Sources/StaticFeatureSource"
import CreateNewNodeAction from "./CreateNewNodeAction"
import ChangeTagAction from "./ChangeTagAction"
import { And } from "../../Tags/And"
import { Utils } from "../../../Utils"
import { OsmConnection } from "../OsmConnection"
import { Feature } from "@turf/turf"
import FeaturePipeline from "../../FeatureSource/FeaturePipeline"
import { Geometry, LineString, Point, Polygon } from "geojson"

export default class ReplaceGeometryAction extends OsmChangeAction {
    /**
     * The target feature - mostly used for the metadata
     */
    private readonly feature: any
    private readonly state: {
        osmConnection: OsmConnection
        featurePipeline: FeaturePipeline
    }
    private readonly wayToReplaceId: string
    private readonly theme: string
    /**
     * The target coordinates that should end up in OpenStreetMap.
     * This is identical to either this.feature.geometry.coordinates or -in case of a polygon- feature.geometry.coordinates[0]
     * Format: [lon, lat]
     */
    private readonly targetCoordinates: [number, number][]
    /**
     * If a target coordinate is close to another target coordinate, 'identicalTo' will point to the first index.
     */
    private readonly identicalTo: number[]
    private readonly newTags: Tag[] | undefined

    constructor(
        state: {
            osmConnection: OsmConnection
            featurePipeline: FeaturePipeline
        },
        feature: any,
        wayToReplaceId: string,
        options: {
            theme: string
            newTags?: Tag[]
        }
    ) {
        super(wayToReplaceId, false)
        this.state = state
        this.feature = feature
        this.wayToReplaceId = wayToReplaceId
        this.theme = options.theme

        const geom = this.feature.geometry
        let coordinates: [number, number][]
        if (geom.type === "LineString") {
            coordinates = geom.coordinates
        } else if (geom.type === "Polygon") {
            coordinates = geom.coordinates[0]
        }
        this.targetCoordinates = coordinates

        this.identicalTo = coordinates.map((_) => undefined)

        for (let i = 0; i < coordinates.length; i++) {
            if (this.identicalTo[i] !== undefined) {
                continue
            }
            for (let j = i + 1; j < coordinates.length; j++) {
                const d = GeoOperations.distanceBetween(coordinates[i], coordinates[j])
                if (d < 0.1) {
                    this.identicalTo[j] = i
                }
            }
        }
        this.newTags = options.newTags
    }

    // noinspection JSUnusedGlobalSymbols
    public async getPreview(): Promise<FeatureSource> {
        const { closestIds, allNodesById, detachedNodes, reprojectedNodes } =
            await this.GetClosestIds()
        const preview: Feature<Geometry>[] = closestIds.map((newId, i) => {
            if (this.identicalTo[i] !== undefined) {
                return undefined
            }

            if (newId === undefined) {
                return {
                    type: "Feature",
                    properties: {
                        newpoint: "yes",
                        id: "replace-geometry-move-" + i,
                    },
                    geometry: {
                        type: "Point",
                        coordinates: this.targetCoordinates[i],
                    },
                }
            }

            const origNode = allNodesById.get(newId)
            return {
                type: "Feature",
                properties: {
                    move: "yes",
                    "osm-id": newId,
                    id: "replace-geometry-move-" + i,
                    "original-node-tags": JSON.stringify(origNode.tags),
                },
                geometry: {
                    type: "LineString",
                    coordinates: [[origNode.lon, origNode.lat], this.targetCoordinates[i]],
                },
            }
        })

        reprojectedNodes.forEach(({ newLat, newLon, nodeId }) => {
            const origNode = allNodesById.get(nodeId)
            const feature: Feature<LineString> = {
                type: "Feature",
                properties: {
                    move: "yes",
                    reprojection: "yes",
                    "osm-id": nodeId,
                    id: "replace-geometry-reproject-" + nodeId,
                    "original-node-tags": JSON.stringify(origNode.tags),
                },
                geometry: {
                    type: "LineString",
                    coordinates: [
                        [origNode.lon, origNode.lat],
                        [newLon, newLat],
                    ],
                },
            }
            preview.push(feature)
        })

        detachedNodes.forEach(({ reason }, id) => {
            const origNode = allNodesById.get(id)
            const feature: Feature<Point> = {
                type: "Feature",
                properties: {
                    detach: "yes",
                    id: "replace-geometry-detach-" + id,
                    "detach-reason": reason,
                    "original-node-tags": JSON.stringify(origNode.tags),
                },
                geometry: {
                    type: "Point",
                    coordinates: [origNode.lon, origNode.lat],
                },
            }
            preview.push(feature)
        })

        return StaticFeatureSource.fromGeojson(Utils.NoNull(preview))
    }

    /**
     * For 'this.feature`, gets a corresponding closest node that alreay exsists.
     *
     * This method contains the main logic for this module, as it decides which node gets moved where.
     *
     */
    public async GetClosestIds(): Promise<{
        // A list of the same length as targetCoordinates, containing which OSM-point to move. If undefined, a new point will be created
        closestIds: number[]
        allNodesById: Map<number, OsmNode>
        osmWay: OsmWay
        detachedNodes: Map<
            number,
            {
                reason: string
                hasTags: boolean
            }
        >
        reprojectedNodes: Map<
            number,
            {
                /*Move the node with this ID into the way as extra node, as it has some relation with the original object*/
                projectAfterIndex: number
                distance: number
                newLat: number
                newLon: number
                nodeId: number
            }
        >
    }> {
        // TODO FIXME: if a new point has to be created, snap to already existing ways

        const nodeDb = this.state.featurePipeline.fullNodeDatabase
        if (nodeDb === undefined) {
            throw "PANIC: replaceGeometryAction needs the FullNodeDatabase, which is undefined. This should be initialized by having the 'type_node'-layer enabled in your theme. (NB: the replacebutton has type_node as dependency)"
        }
        const self = this
        let parsed: OsmObject[]
        {
            // Gather the needed OsmObjects
            const splitted = this.wayToReplaceId.split("/")
            const type = splitted[0]
            const idN = Number(splitted[1])
            if (idN < 0 || type !== "way") {
                throw "Invalid ID to conflate: " + this.wayToReplaceId
            }
            const url = `${
                this.state.osmConnection?._oauth_config?.url ?? "https://openstreetmap.org"
            }/api/0.6/${this.wayToReplaceId}/full`
            const rawData = await Utils.downloadJsonCached(url, 1000)
            parsed = OsmObject.ParseObjects(rawData.elements)
        }
        const allNodes = parsed.filter((o) => o.type === "node")
        const osmWay = <OsmWay>parsed[parsed.length - 1]
        if (osmWay.type !== "way") {
            throw "WEIRD: expected an OSM-way as last element here!"
        }
        const allNodesById = new Map<number, OsmNode>()
        for (const node of allNodes) {
            allNodesById.set(node.id, <OsmNode>node)
        }
        /**
         * For every already existing OSM-point, we calculate:
         *
         * - the distance to every target point.
         * - Wether this node has (other) parent ways, which might restrict movement
         * - Wether this node has tags set
         *
         * Having tags and/or being connected to another way indicate that there is some _relation_ with objects in the neighbourhood.
         *
         * The Replace-geometry action should try its best to honour these. Some 'wiggling' is allowed (e.g. moving an entrance a bit), but these relations should not be broken.l
         */
        const distances = new Map<
            number /* osmId*/,
            /** target coordinate index --> distance (or undefined if a duplicate)*/
            number[]
        >()

        const nodeInfo = new Map<
            number /* osmId*/,
            {
                distances: number[]
                // Part of some other way then the one that should be replaced
                partOfWay: boolean
                hasTags: boolean
            }
        >()

        for (const node of allNodes) {
            const parentWays = nodeDb.GetParentWays(node.id)
            if (parentWays === undefined) {
                throw "PANIC: the way to replace has a node which has no parents at all. Is it deleted in the meantime?"
            }
            const parentWayIds = parentWays.data.map((w) => w.type + "/" + w.id)
            const idIndex = parentWayIds.indexOf(this.wayToReplaceId)
            if (idIndex < 0) {
                throw "PANIC: the way to replace has a node, which is _not_ part of this was according to the node..."
            }
            parentWayIds.splice(idIndex, 1)
            const partOfSomeWay = parentWayIds.length > 0
            const hasTags = Object.keys(node.tags).length > 1

            const nodeDistances = this.targetCoordinates.map((_) => undefined)
            for (let i = 0; i < this.targetCoordinates.length; i++) {
                if (this.identicalTo[i] !== undefined) {
                    continue
                }
                const targetCoordinate = this.targetCoordinates[i]
                const cp = node.centerpoint()
                const d = GeoOperations.distanceBetween(targetCoordinate, [cp[1], cp[0]])
                if (d > 25) {
                    // This is too much to move
                    continue
                }
                if (d < 3 || !(hasTags || partOfSomeWay)) {
                    // If there is some relation: cap the move distance to 3m
                    nodeDistances[i] = d
                }
            }
            distances.set(node.id, nodeDistances)
            nodeInfo.set(node.id, {
                distances: nodeDistances,
                partOfWay: partOfSomeWay,
                hasTags,
            })
        }

        const closestIds = this.targetCoordinates.map((_) => undefined)
        const unusedIds = new Map<
            number,
            {
                reason: string
                hasTags: boolean
            }
        >()
        {
            // Search best merge candidate
            /**
             * Then, we search the node that has to move the least distance and add this as mapping.
             * We do this until no points are left
             */
            let candidate: number
            let moveDistance: number
            /**
             * The list of nodes that are _not_ used anymore, typically if there are less targetCoordinates then source coordinates
             */
            do {
                candidate = undefined
                moveDistance = Infinity
                distances.forEach((distances, nodeId) => {
                    const minDist = Math.min(...Utils.NoNull(distances))
                    if (moveDistance > minDist) {
                        // We have found a candidate to move
                        candidate = nodeId
                        moveDistance = minDist
                    }
                })

                if (candidate !== undefined) {
                    // We found a candidate... Search the corresponding target id:
                    let targetId: number = undefined
                    let lowestDistance = Number.MAX_VALUE
                    let nodeDistances = distances.get(candidate)
                    for (let i = 0; i < nodeDistances.length; i++) {
                        const d = nodeDistances[i]
                        if (d !== undefined && d < lowestDistance) {
                            lowestDistance = d
                            targetId = i
                        }
                    }

                    // This candidates role is done, it can be removed from the distance matrix
                    distances.delete(candidate)

                    if (targetId !== undefined) {
                        // At this point, we have our target coordinate index: targetId!
                        // Lets map it...
                        closestIds[targetId] = candidate

                        // To indicate that this targetCoordinate is taken, we remove them from the distances matrix
                        distances.forEach((dists) => {
                            dists[targetId] = undefined
                        })
                    } else {
                        // Seems like all the targetCoordinates have found a source point
                        unusedIds.set(candidate, {
                            reason: "Unused by new way",
                            hasTags: nodeInfo.get(candidate).hasTags,
                        })
                    }
                }
            } while (candidate !== undefined)
        }

        // If there are still unused values in 'distances', they are definitively unused
        distances.forEach((_, nodeId) => {
            unusedIds.set(nodeId, {
                reason: "Unused by new way",
                hasTags: nodeInfo.get(nodeId).hasTags,
            })
        })

        const reprojectedNodes = new Map<
            number,
            {
                /*Move the node with this ID into the way as extra node, as it has some relation with the original object*/
                projectAfterIndex: number
                distance: number
                newLat: number
                newLon: number
                nodeId: number
            }
        >()
        {
            // Lets check the unused ids: can they be detached or do they signify some relation with the object?
            unusedIds.forEach(({}, id) => {
                const info = nodeInfo.get(id)
                if (!(info.hasTags || info.partOfWay)) {
                    // Nothing special here, we detach
                    return
                }

                // The current node has tags and/or has an attached other building.
                // We should project them and move them onto the building on an appropriate place
                const node = allNodesById.get(id)

                // Project the node onto the target way to calculate the new coordinates
                const way = <Feature<LineString>>{
                    type: "Feature",
                    properties: {},
                    geometry: {
                        type: "LineString",
                        coordinates: self.targetCoordinates,
                    },
                }
                const projected = GeoOperations.nearestPoint(way, [node.lon, node.lat])
                reprojectedNodes.set(id, {
                    newLon: projected.geometry.coordinates[0],
                    newLat: projected.geometry.coordinates[1],
                    projectAfterIndex: projected.properties.index,
                    distance: projected.properties.dist,
                    nodeId: id,
                })
            })

            reprojectedNodes.forEach((_, nodeId) => unusedIds.delete(nodeId))
        }

        return { closestIds, allNodesById, osmWay, detachedNodes: unusedIds, reprojectedNodes }
    }

    protected async CreateChangeDescriptions(changes: Changes): Promise<ChangeDescription[]> {
        const nodeDb = this.state.featurePipeline.fullNodeDatabase
        if (nodeDb === undefined) {
            throw "PANIC: replaceGeometryAction needs the FullNodeDatabase, which is undefined. This should be initialized by having the 'type_node'-layer enabled in your theme. (NB: the replacebutton has type_node as dependency)"
        }

        const { closestIds, osmWay, detachedNodes, reprojectedNodes } = await this.GetClosestIds()
        const allChanges: ChangeDescription[] = []
        const actualIdsToUse: number[] = []
        for (let i = 0; i < closestIds.length; i++) {
            if (this.identicalTo[i] !== undefined) {
                const j = this.identicalTo[i]
                actualIdsToUse.push(actualIdsToUse[j])
                continue
            }
            const closestId = closestIds[i]
            const [lon, lat] = this.targetCoordinates[i]
            if (closestId === undefined) {
                const newNodeAction = new CreateNewNodeAction([], lat, lon, {
                    allowReuseOfPreviouslyCreatedPoints: true,
                    theme: this.theme,
                    changeType: null,
                })
                const changeDescr = await newNodeAction.CreateChangeDescriptions(changes)
                allChanges.push(...changeDescr)
                actualIdsToUse.push(newNodeAction.newElementIdNumber)
            } else {
                const change = <ChangeDescription>{
                    id: closestId,
                    type: "node",
                    meta: {
                        theme: this.theme,
                        changeType: "move",
                    },
                    changes: { lon, lat },
                }
                actualIdsToUse.push(closestId)
                allChanges.push(change)
            }
        }

        if (this.newTags !== undefined && this.newTags.length > 0) {
            const addExtraTags = new ChangeTagAction(
                this.wayToReplaceId,
                new And(this.newTags),
                osmWay.tags,
                {
                    theme: this.theme,
                    changeType: "conflation",
                }
            )
            allChanges.push(...(await addExtraTags.CreateChangeDescriptions(changes)))
        }

        const newCoordinates = [...this.targetCoordinates]

        {
            // Add reprojected nodes to the way

            const proj = Array.from(reprojectedNodes.values())
            proj.sort((a, b) => {
                // Sort descending
                const diff = b.projectAfterIndex - a.projectAfterIndex
                if (diff !== 0) {
                    return diff
                }
                return b.distance - a.distance
            })

            for (const reprojectedNode of proj) {
                const change = <ChangeDescription>{
                    id: reprojectedNode.nodeId,
                    type: "node",
                    meta: {
                        theme: this.theme,
                        changeType: "move",
                    },
                    changes: { lon: reprojectedNode.newLon, lat: reprojectedNode.newLat },
                }
                allChanges.push(change)
                actualIdsToUse.splice(
                    reprojectedNode.projectAfterIndex + 1,
                    0,
                    reprojectedNode.nodeId
                )
                newCoordinates.splice(reprojectedNode.projectAfterIndex + 1, 0, [
                    reprojectedNode.newLon,
                    reprojectedNode.newLat,
                ])
            }
        }

        // Actually change the nodes of the way!
        allChanges.push({
            type: "way",
            id: osmWay.id,
            changes: {
                nodes: actualIdsToUse,
                coordinates: newCoordinates,
            },
            meta: {
                theme: this.theme,
                changeType: "conflation",
            },
        })

        // Some nodes might need to be deleted
        if (detachedNodes.size > 0) {
            detachedNodes.forEach(({ hasTags, reason }, nodeId) => {
                const parentWays = nodeDb.GetParentWays(nodeId)
                const index = parentWays.data.map((w) => w.id).indexOf(osmWay.id)
                if (index < 0) {
                    console.error(
                        "ReplaceGeometryAction is trying to detach node " +
                            nodeId +
                            ", but it isn't listed as being part of way " +
                            osmWay.id
                    )
                    return
                }
                // We detachted this node - so we unregister
                parentWays.data.splice(index, 1)
                parentWays.ping()

                if (hasTags) {
                    // Has tags: we leave this node alone
                    return
                }
                if (parentWays.data.length != 0) {
                    // Still part of other ways: we leave this node alone!
                    return
                }

                console.log("Removing node " + nodeId, "as it isn't needed anymore by any way")
                allChanges.push({
                    meta: {
                        theme: this.theme,
                        changeType: "delete",
                    },
                    doDelete: true,
                    type: "node",
                    id: nodeId,
                })
            })
        }

        return allChanges
    }
}