MapComplete/Models/ThemeConfig/Conversion/PrepareTheme.ts

import {
    Concat,
    Conversion,
    DesugaringContext,
    DesugaringStep,
    Each,
    Fuse,
    On,
    Pass,
    SetDefault,
} from "./Conversion"
import { LayoutConfigJson } from "../Json/LayoutConfigJson"
import { PrepareLayer } from "./PrepareLayer"
import { LayerConfigJson } from "../Json/LayerConfigJson"
import { Utils } from "../../../Utils"
import Constants from "../../Constants"
import CreateNoteImportLayer from "./CreateNoteImportLayer"
import LayerConfig from "../LayerConfig"
import { TagRenderingConfigJson } from "../Json/TagRenderingConfigJson"
import { SubstitutedTranslation } from "../../../UI/SubstitutedTranslation"
import DependencyCalculator from "../DependencyCalculator"
import { AddContextToTranslations } from "./AddContextToTranslations"

class SubstituteLayer extends Conversion<string | LayerConfigJson, LayerConfigJson[]> {
    private readonly _state: DesugaringContext

    constructor(state: DesugaringContext) {
        super(
            "Converts the identifier of a builtin layer into the actual layer, or converts a 'builtin' syntax with override in the fully expanded form",
            [],
            "SubstituteLayer"
        )
        this._state = state
    }

    convert(
        json: string | LayerConfigJson,
        context: string
    ): { result: LayerConfigJson[]; errors: string[]; information?: string[] } {
        const errors = []
        const information = []
        const state = this._state

        function reportNotFound(name: string) {
            const knownLayers = Array.from(state.sharedLayers.keys())
            const withDistance = knownLayers.map((lname) => [
                lname,
                Utils.levenshteinDistance(name, lname),
            ])
            withDistance.sort((a, b) => a[1] - b[1])
            const ids = withDistance.map((n) => n[0])
            // Known builtin layers are "+.join(",")+"\n    For more information, see "
            errors.push(`${context}: The layer with name ${name} was not found as a builtin layer. Perhaps you meant ${ids[0]}, ${ids[1]} or ${ids[2]}?
 For an overview of all available layers, refer to https://github.com/pietervdvn/MapComplete/blob/develop/Docs/BuiltinLayers.md`)
        }

        if (typeof json === "string") {
            const found = state.sharedLayers.get(json)
            if (found === undefined) {
                reportNotFound(json)
                return {
                    result: null,
                    errors,
                }
            }
            return {
                result: [found],
                errors,
            }
        }

        if (json["builtin"] !== undefined) {
            let names = json["builtin"]
            if (typeof names === "string") {
                names = [names]
            }
            const layers = []

            for (const name of names) {
                const found = Utils.Clone(state.sharedLayers.get(name))
                if (found === undefined) {
                    reportNotFound(name)
                    continue
                }
                if (
                    json["override"]["tagRenderings"] !== undefined &&
                    (found["tagRenderings"] ?? []).length > 0
                ) {
                    errors.push(
                        `At ${context}: when overriding a layer, an override is not allowed to override into tagRenderings. Use "+tagRenderings" or "tagRenderings+" instead to prepend or append some questions.`
                    )
                }
                try {
                    Utils.Merge(json["override"], found)
                    layers.push(found)
                } catch (e) {
                    errors.push(
                        `At ${context}: could not apply an override due to: ${e}.\nThe override is: ${JSON.stringify(
                            json["override"]
                        )}`
                    )
                }

                if (json["hideTagRenderingsWithLabels"]) {
                    const hideLabels: Set<string> = new Set(json["hideTagRenderingsWithLabels"])
                    // These labels caused at least one deletion
                    const usedLabels: Set<string> = new Set<string>()
                    const filtered = []
                    for (const tr of found.tagRenderings) {
                        const labels = tr["labels"]
                        if (labels !== undefined) {
                            const forbiddenLabel = labels.findIndex((l) => hideLabels.has(l))
                            if (forbiddenLabel >= 0) {
                                usedLabels.add(labels[forbiddenLabel])
                                information.push(
                                    context +
                                        ": Dropping tagRendering " +
                                        tr["id"] +
                                        " as it has a forbidden label: " +
                                        labels[forbiddenLabel]
                                )
                                continue
                            }
                        }

                        if (hideLabels.has(tr["id"])) {
                            usedLabels.add(tr["id"])
                            information.push(
                                context +
                                    ": Dropping tagRendering " +
                                    tr["id"] +
                                    " as its id is a forbidden label"
                            )
                            continue
                        }

                        if (hideLabels.has(tr["group"])) {
                            usedLabels.add(tr["group"])
                            information.push(
                                context +
                                    ": Dropping tagRendering " +
                                    tr["id"] +
                                    " as its group `" +
                                    tr["group"] +
                                    "` is a forbidden label"
                            )
                            continue
                        }

                        filtered.push(tr)
                    }
                    const unused = Array.from(hideLabels).filter((l) => !usedLabels.has(l))
                    if (unused.length > 0) {
                        errors.push(
                            "This theme specifies that certain tagrenderings have to be removed based on forbidden layers. One or more of these layers did not match any tagRenderings and caused no deletions: " +
                                unused.join(", ") +
                                "\n   This means that this label can be removed or that the original tagRendering that should be deleted does not have this label anymore"
                        )
                    }
                    found.tagRenderings = filtered
                }
            }
            return {
                result: layers,
                errors,
                information,
            }
        }

        return {
            result: [json],
            errors,
        }
    }
}

class AddDefaultLayers extends DesugaringStep<LayoutConfigJson> {
    private _state: DesugaringContext

    constructor(state: DesugaringContext) {
        super(
            "Adds the default layers, namely: " + Constants.added_by_default.join(", "),
            ["layers"],
            "AddDefaultLayers"
        )
        this._state = state
    }

    convert(
        json: LayoutConfigJson,
        context: string
    ): { result: LayoutConfigJson; errors: string[]; warnings: string[] } {
        const errors = []
        const warnings = []
        const state = this._state
        json.layers = [...json.layers]
        const alreadyLoaded = new Set(json.layers.map((l) => l["id"]))

        for (const layerName of Constants.added_by_default) {
            const v = state.sharedLayers.get(layerName)
            if (v === undefined) {
                errors.push("Default layer " + layerName + " not found")
                continue
            }
            if (alreadyLoaded.has(v.id)) {
                warnings.push(
                    "Layout " +
                        context +
                        " already has a layer with name " +
                        v.id +
                        "; skipping inclusion of this builtin layer"
                )
                continue
            }
            json.layers.push(v)
        }

        return {
            result: json,
            errors,
            warnings,
        }
    }
}

class AddImportLayers extends DesugaringStep<LayoutConfigJson> {
    constructor() {
        super(
            "For every layer in the 'layers'-list, create a new layer which'll import notes. (Note that priviliged layers and layers which have a geojson-source set are ignored)",
            ["layers"],
            "AddImportLayers"
        )
    }

    convert(
        json: LayoutConfigJson,
        context: string
    ): { result: LayoutConfigJson; errors?: string[]; warnings?: string[] } {
        if (!(json.enableNoteImports ?? true)) {
            return {
                warnings: [
                    "Not creating a note import layers for theme " +
                        json.id +
                        " as they are disabled",
                ],
                result: json,
            }
        }
        const errors = []

        json = { ...json }
        const allLayers: LayerConfigJson[] = <LayerConfigJson[]>json.layers
        json.layers = [...json.layers]

        const creator = new CreateNoteImportLayer()
        for (let i1 = 0; i1 < allLayers.length; i1++) {
            const layer = allLayers[i1]
            if (Constants.priviliged_layers.indexOf(layer.id) >= 0) {
                // Priviliged layers are skipped
                continue
            }

            if (layer.source["geoJson"] !== undefined) {
                // Layer which don't get their data from OSM are skipped
                continue
            }

            if (layer.title === undefined || layer.name === undefined) {
                // Anonymous layers and layers without popup are skipped
                continue
            }

            if (layer.presets === undefined || layer.presets.length == 0) {
                // A preset is needed to be able to generate a new point
                continue
            }

            try {
                const importLayerResult = creator.convert(
                    layer,
                    context + ".(noteimportlayer)[" + i1 + "]"
                )
                if (importLayerResult.result !== undefined) {
                    json.layers.push(importLayerResult.result)
                }
            } catch (e) {
                errors.push("Could not generate an import-layer for " + layer.id + " due to " + e)
            }
        }

        return {
            errors,
            result: json,
        }
    }
}

export class AddMiniMap extends DesugaringStep<LayerConfigJson> {
    private readonly _state: DesugaringContext

    constructor(state: DesugaringContext) {
        super(
            "Adds a default 'minimap'-element to the tagrenderings if none of the elements define such a minimap",
            ["tagRenderings"],
            "AddMiniMap"
        )
        this._state = state
    }

    /**
     * Returns true if this tag rendering has a minimap in some language.
     * Note: this minimap can be hidden by conditions
     *
     * AddMiniMap.hasMinimap({render: "{minimap()}"}) // => true
     * AddMiniMap.hasMinimap({render: {en: "{minimap()}"}}) // => true
     * AddMiniMap.hasMinimap({render: {en: "{minimap()}", nl: "{minimap()}"}}) // => true
     * AddMiniMap.hasMinimap({render: {en: "{minimap()}", nl: "No map for the dutch!"}}) // => true
     * AddMiniMap.hasMinimap({render: "{minimap()}"}) // => true
     * AddMiniMap.hasMinimap({render: "{minimap(18,featurelist)}"}) // => true
     * AddMiniMap.hasMinimap({mappings: [{if: "xyz=abc",then: "{minimap(18,featurelist)}"}]}) // => true
     * AddMiniMap.hasMinimap({render: "Some random value {key}"}) // => false
     * AddMiniMap.hasMinimap({render: "Some random value {minimap}"}) // => false
     */
    static hasMinimap(renderingConfig: TagRenderingConfigJson): boolean {
        const translations: any[] = Utils.NoNull([
            renderingConfig.render,
            ...(renderingConfig.mappings ?? []).map((m) => m.then),
        ])
        for (let translation of translations) {
            if (typeof translation == "string") {
                translation = { "*": translation }
            }

            for (const key in translation) {
                if (!translation.hasOwnProperty(key)) {
                    continue
                }

                const template = translation[key]
                const parts = SubstitutedTranslation.ExtractSpecialComponents(template)
                const hasMiniMap = parts
                    .filter((part) => part.special !== undefined)
                    .some((special) => special.special.func.funcName === "minimap")
                if (hasMiniMap) {
                    return true
                }
            }
        }
        return false
    }

    convert(layerConfig: LayerConfigJson, context: string): { result: LayerConfigJson } {
        const state = this._state
        const hasMinimap =
            layerConfig.tagRenderings?.some((tr) =>
                AddMiniMap.hasMinimap(<TagRenderingConfigJson>tr)
            ) ?? true
        if (!hasMinimap) {
            layerConfig = { ...layerConfig }
            layerConfig.tagRenderings = [...layerConfig.tagRenderings]
            layerConfig.tagRenderings.push(state.tagRenderings.get("questions"))
            layerConfig.tagRenderings.push(state.tagRenderings.get("minimap"))
        }

        return {
            result: layerConfig,
        }
    }
}

class AddContextToTransltionsInLayout extends DesugaringStep<LayoutConfigJson> {
    constructor() {
        super(
            "Adds context to translations, including the prefix 'themes:json.id'; this is to make sure terms in an 'overrides' or inline layer are linkable too",
            ["_context"],
            "AddContextToTranlationsInLayout"
        )
    }

    convert(
        json: LayoutConfigJson,
        context: string
    ): {
        result: LayoutConfigJson
        errors?: string[]
        warnings?: string[]
        information?: string[]
    } {
        const conversion = new AddContextToTranslations<LayoutConfigJson>("themes:")
        return conversion.convert(json, json.id)
    }
}

class ApplyOverrideAll extends DesugaringStep<LayoutConfigJson> {
    constructor() {
        super(
            "Applies 'overrideAll' onto every 'layer'. The 'overrideAll'-field is removed afterwards",
            ["overrideAll", "layers"],
            "ApplyOverrideAll"
        )
    }

    convert(
        json: LayoutConfigJson,
        context: string
    ): { result: LayoutConfigJson; errors: string[]; warnings: string[] } {
        const overrideAll = json.overrideAll
        if (overrideAll === undefined) {
            return { result: json, warnings: [], errors: [] }
        }

        json = { ...json }

        delete json.overrideAll
        const newLayers = []
        for (let layer of json.layers) {
            layer = Utils.Clone(<LayerConfigJson>layer)
            Utils.Merge(overrideAll, layer)
            newLayers.push(layer)
        }
        json.layers = newLayers

        return { result: json, warnings: [], errors: [] }
    }
}

class AddDependencyLayersToTheme extends DesugaringStep<LayoutConfigJson> {
    private readonly _state: DesugaringContext

    constructor(state: DesugaringContext) {
        super(
            `If a layer has a dependency on another layer, these layers are added automatically on the theme. (For example: defibrillator depends on 'walls_and_buildings' to snap onto. This layer is added automatically)
            
            Note that these layers are added _at the start_ of the layer list, meaning that they will see _every_ feature.
            Furthermore, \`passAllFeatures\` will be set, so that they won't steal away features from further layers.
            Some layers (e.g. \`all_buildings_and_walls\' or \'streets_with_a_name\') are invisible, so by default, \'force_load\' is set too.
            `,
            ["layers"],
            "AddDependencyLayersToTheme"
        )
        this._state = state
    }

    private static CalculateDependencies(
        alreadyLoaded: LayerConfigJson[],
        allKnownLayers: Map<string, LayerConfigJson>,
        themeId: string
    ): { config: LayerConfigJson; reason: string }[] {
        const dependenciesToAdd: { config: LayerConfigJson; reason: string }[] = []
        const loadedLayerIds: Set<string> = new Set<string>(alreadyLoaded.map((l) => l.id))

        // Verify cross-dependencies
        let unmetDependencies: {
            neededLayer: string
            neededBy: string
            reason: string
            context?: string
        }[] = []
        do {
            const dependencies: {
                neededLayer: string
                reason: string
                context?: string
                neededBy: string
            }[] = []

            for (const layerConfig of alreadyLoaded) {
                try {
                    const layerDeps = DependencyCalculator.getLayerDependencies(
                        new LayerConfig(layerConfig, themeId + "(dependencies)")
                    )
                    dependencies.push(...layerDeps)
                } catch (e) {
                    console.error(e)
                    throw (
                        "Detecting layer dependencies for " + layerConfig.id + " failed due to " + e
                    )
                }
            }

            for (const dependency of dependencies) {
                if (loadedLayerIds.has(dependency.neededLayer)) {
                    // We mark the needed layer as 'mustLoad'
                    alreadyLoaded.find((l) => l.id === dependency.neededLayer).forceLoad = true
                }
            }

            // During the generate script, builtin layers are verified but not loaded - so we have to add them manually here
            // Their existence is checked elsewhere, so this is fine
            unmetDependencies = dependencies.filter((dep) => !loadedLayerIds.has(dep.neededLayer))
            for (const unmetDependency of unmetDependencies) {
                if (loadedLayerIds.has(unmetDependency.neededLayer)) {
                    continue
                }
                const dep = Utils.Clone(allKnownLayers.get(unmetDependency.neededLayer))
                const reason =
                    "This layer is needed by " +
                    unmetDependency.neededBy +
                    " because " +
                    unmetDependency.reason +
                    " (at " +
                    unmetDependency.context +
                    ")"
                if (dep === undefined) {
                    const message = [
                        "Loading a dependency failed: layer " +
                            unmetDependency.neededLayer +
                            " is not found, neither as layer of " +
                            themeId +
                            " nor as builtin layer.",
                        reason,
                        "Loaded layers are: " + alreadyLoaded.map((l) => l.id).join(","),
                    ]
                    throw message.join("\n\t")
                }

                dep.forceLoad = true
                dep.passAllFeatures = true
                dep.description = reason
                dependenciesToAdd.unshift({
                    config: dep,
                    reason,
                })
                loadedLayerIds.add(dep.id)
                unmetDependencies = unmetDependencies.filter(
                    (d) => d.neededLayer !== unmetDependency.neededLayer
                )
            }
        } while (unmetDependencies.length > 0)

        return dependenciesToAdd
    }

    convert(
        theme: LayoutConfigJson,
        context: string
    ): { result: LayoutConfigJson; information: string[] } {
        const state = this._state
        const allKnownLayers: Map<string, LayerConfigJson> = state.sharedLayers
        const knownTagRenderings: Map<string, TagRenderingConfigJson> = state.tagRenderings
        const information = []
        const layers: LayerConfigJson[] = <LayerConfigJson[]>theme.layers // Layers should be expanded at this point

        knownTagRenderings.forEach((value, key) => {
            value.id = key
        })

        const dependencies = AddDependencyLayersToTheme.CalculateDependencies(
            layers,
            allKnownLayers,
            theme.id
        )
        for (const dependency of dependencies) {
        }
        if (dependencies.length > 0) {
            for (const dependency of dependencies) {
                information.push(
                    context +
                        ": added " +
                        dependency.config.id +
                        " to the theme. " +
                        dependency.reason
                )
            }
        }
        layers.unshift(...dependencies.map((l) => l.config))

        return {
            result: {
                ...theme,
                layers: layers,
            },
            information,
        }
    }
}

class PreparePersonalTheme extends DesugaringStep<LayoutConfigJson> {
    private readonly _state: DesugaringContext

    constructor(state: DesugaringContext) {
        super("Adds every public layer to the personal theme", ["layers"], "PreparePersonalTheme")
        this._state = state
    }

    convert(
        json: LayoutConfigJson,
        context: string
    ): {
        result: LayoutConfigJson
        errors?: string[]
        warnings?: string[]
        information?: string[]
    } {
        if (json.id !== "personal") {
            return { result: json }
        }

        // The only thing this _really_ does, is adding the layer-ids into 'layers'
        // All other preparations are done by the 'override-all'-block in personal.json

        json.layers = Array.from(this._state.sharedLayers.keys())
            .filter((l) => Constants.priviliged_layers.indexOf(l) < 0)
            .filter((l) => this._state.publicLayers.has(l))
        return {
            result: json,
            information: ["The personal theme has " + json.layers.length + " public layers"],
        }
    }
}

class WarnForUnsubstitutedLayersInTheme extends DesugaringStep<LayoutConfigJson> {
    constructor() {
        super(
            "Generates a warning if a theme uses an unsubstituted layer",
            ["layers"],
            "WarnForUnsubstitutedLayersInTheme"
        )
    }

    convert(
        json: LayoutConfigJson,
        context: string
    ): {
        result: LayoutConfigJson
        errors?: string[]
        warnings?: string[]
        information?: string[]
    } {
        if (json.hideFromOverview === true) {
            return { result: json }
        }
        const warnings = []
        for (const layer of json.layers) {
            if (typeof layer === "string") {
                continue
            }
            if (layer["builtin"] !== undefined) {
                continue
            }
            if (layer["source"]["geojson"] !== undefined) {
                // We turn a blind eye for import layers
                continue
            }

            const wrn =
                "The theme " +
                json.id +
                " has an inline layer: " +
                layer["id"] +
                ". This is discouraged."
            warnings.push(wrn)
        }
        return {
            result: json,
            warnings,
        }
    }
}

export class PrepareTheme extends Fuse<LayoutConfigJson> {
    constructor(
        state: DesugaringContext,
        options?: {
            skipDefaultLayers: false | boolean
        }
    ) {
        super(
            "Fully prepares and expands a theme",

            new AddContextToTransltionsInLayout(),
            new PreparePersonalTheme(state),
            new WarnForUnsubstitutedLayersInTheme(),
            new On("layers", new Concat(new SubstituteLayer(state))),
            new SetDefault("socialImage", "assets/SocialImage.png", true),
            // We expand all tagrenderings first...
            new On("layers", new Each(new PrepareLayer(state))),
            // Then we apply the override all
            new ApplyOverrideAll(),
            // And then we prepare all the layers _again_ in case that an override all contained unexpanded tagrenderings!
            new On("layers", new Each(new PrepareLayer(state))),
            options?.skipDefaultLayers
                ? new Pass("AddDefaultLayers is disabled due to the set flag")
                : new AddDefaultLayers(state),
            new AddDependencyLayersToTheme(state),
            new AddImportLayers(),
            new On("layers", new Each(new AddMiniMap(state)))
        )
    }
}