MapComplete/Logic/Osm/Actions/CreateMultiPolygonWithPointReuseAction.ts

import { OsmCreateAction } from "./OsmChangeAction"
import { Tag } from "../../Tags/Tag"
import { Changes } from "../Changes"
import { ChangeDescription } from "./ChangeDescription"
import FeaturePipelineState from "../../State/FeaturePipelineState"
import FeatureSource from "../../FeatureSource/FeatureSource"
import CreateNewWayAction from "./CreateNewWayAction"
import CreateWayWithPointReuseAction, { MergePointConfig } from "./CreateWayWithPointReuseAction"
import { And } from "../../Tags/And"
import { TagUtils } from "../../Tags/TagUtils"

/**
 * More or less the same as 'CreateNewWay', except that it'll try to reuse already existing points
 */
export default class CreateMultiPolygonWithPointReuseAction extends OsmCreateAction {
    public newElementId: string = undefined
    public newElementIdNumber: number = undefined
    private readonly _tags: Tag[]
    private readonly createOuterWay: CreateWayWithPointReuseAction
    private readonly createInnerWays: CreateNewWayAction[]
    private readonly geojsonPreview: any
    private readonly theme: string
    private readonly changeType: "import" | "create" | string

    constructor(
        tags: Tag[],
        outerRingCoordinates: [number, number][],
        innerRingsCoordinates: [number, number][][],
        state: FeaturePipelineState,
        config: MergePointConfig[],
        changeType: "import" | "create" | string
    ) {
        super(null, true)
        this._tags = [...tags, new Tag("type", "multipolygon")]
        this.changeType = changeType
        this.theme = state?.layoutToUse?.id ?? ""
        this.createOuterWay = new CreateWayWithPointReuseAction(
            [],
            outerRingCoordinates,
            state,
            config
        )
        this.createInnerWays = innerRingsCoordinates.map(
            (ringCoordinates) =>
                new CreateNewWayAction(
                    [],
                    ringCoordinates.map(([lon, lat]) => ({ lat, lon })),
                    { theme: state?.layoutToUse?.id }
                )
        )

        this.geojsonPreview = {
            type: "Feature",
            properties: TagUtils.changeAsProperties(new And(this._tags).asChange({})),
            geometry: {
                type: "Polygon",
                coordinates: [outerRingCoordinates, ...innerRingsCoordinates],
            },
        }
    }

    public async getPreview(): Promise<FeatureSource> {
        const outerPreview = await this.createOuterWay.getPreview()
        outerPreview.features.data.push({
            freshness: new Date(),
            feature: this.geojsonPreview,
        })
        return outerPreview
    }

    protected async CreateChangeDescriptions(changes: Changes): Promise<ChangeDescription[]> {
        console.log("Running CMPWPRA")
        const descriptions: ChangeDescription[] = []
        descriptions.push(...(await this.createOuterWay.CreateChangeDescriptions(changes)))
        for (const innerWay of this.createInnerWays) {
            descriptions.push(...(await innerWay.CreateChangeDescriptions(changes)))
        }

        this.newElementIdNumber = changes.getNewID()
        this.newElementId = "relation/" + this.newElementIdNumber
        descriptions.push({
            type: "relation",
            id: this.newElementIdNumber,
            tags: new And(this._tags).asChange({}),
            meta: {
                theme: this.theme,
                changeType: this.changeType,
            },
            changes: {
                members: [
                    {
                        type: "way",
                        ref: this.createOuterWay.newElementIdNumber,
                        role: "outer",
                    },
                    // @ts-ignore
                    ...this.createInnerWays.map((a) => ({
                        type: "way",
                        ref: a.newElementIdNumber,
                        role: "inner",
                    })),
                ],
            },
        })

        return descriptions
    }
}