MapComplete/UI/AutomatonGui.ts

import BaseUIElement from "./BaseUIElement";
import Combine from "./Base/Combine";
import Svg from "../Svg";
import Title from "./Base/Title";
import Toggle from "./Input/Toggle";
import {SubtleButton} from "./Base/SubtleButton";
import LayoutConfig from "../Models/ThemeConfig/LayoutConfig";
import ValidatedTextField from "./Input/ValidatedTextField";
import {Utils} from "../Utils";
import {UIEventSource} from "../Logic/UIEventSource";
import {VariableUiElement} from "./Base/VariableUIElement";
import {FixedUiElement} from "./Base/FixedUiElement";
import {Tiles} from "../Models/TileRange";
import {LocalStorageSource} from "../Logic/Web/LocalStorageSource";
import {DropDown} from "./Input/DropDown";
import {AllKnownLayouts} from "../Customizations/AllKnownLayouts";
import MinimapImplementation from "./Base/MinimapImplementation";
import {OsmConnection} from "../Logic/Osm/OsmConnection";
import {BBox} from "../Logic/BBox";
import MapState from "../Logic/State/MapState";
import FeaturePipeline from "../Logic/FeatureSource/FeaturePipeline";
import LayerConfig from "../Models/ThemeConfig/LayerConfig";
import TagRenderingConfig from "../Models/ThemeConfig/TagRenderingConfig";
import FeatureSource from "../Logic/FeatureSource/FeatureSource";
import List from "./Base/List";
import {QueryParameters} from "../Logic/Web/QueryParameters";
import {SubstitutedTranslation} from "./SubstitutedTranslation";
import {AutoAction} from "./Popup/AutoApplyButton";
import DynamicGeoJsonTileSource from "../Logic/FeatureSource/TiledFeatureSource/DynamicGeoJsonTileSource";
import * as themeOverview from "../assets/generated/theme_overview.json"


class AutomationPanel extends Combine {
    private static readonly openChangeset = new UIEventSource<number>(undefined);

    constructor(layoutToUse: LayoutConfig, indices: number[], extraCommentText: UIEventSource<string>, tagRenderingToAutomate: { layer: LayerConfig, tagRendering: TagRenderingConfig }) {
        const layerId = tagRenderingToAutomate.layer.id
        const trId = tagRenderingToAutomate.tagRendering.id
        const tileState = LocalStorageSource.GetParsed("automation-tile_state-" + layerId + "-" + trId, {})
        const logMessages = new UIEventSource<string[]>([])
        if (indices === undefined) {
            throw ("No tiles loaded - can not automate")
        }
        const openChangeset = AutomationPanel.openChangeset;

        openChangeset.addCallbackAndRun(cs => console.trace("Sync current open changeset to:", cs))

        const nextTileToHandle = tileState.map(handledTiles => {
            for (const index of indices) {
                if (handledTiles[index] !== undefined) {
                    // Already handled
                    continue
                }
                return index
            }
            return undefined
        })
        nextTileToHandle.addCallback(t => console.warn("Next tile to handle is", t))

        const neededTimes = new UIEventSource<number[]>([])
        const automaton = new VariableUiElement(nextTileToHandle.map(tileIndex => {
            if (tileIndex === undefined) {
                return new FixedUiElement("All done!").SetClass("thanks")
            }
            console.warn("Triggered map on nextTileToHandle", tileIndex)
            const start = new Date()
            return AutomationPanel.TileHandler(layoutToUse, tileIndex, layerId, tagRenderingToAutomate.tagRendering, extraCommentText,
                (result, logMessage) => {
                    const end = new Date()
                    const timeNeeded = (end.getTime() - start.getTime()) / 1000;
                    neededTimes.data.push(timeNeeded)
                    neededTimes.ping()
                    tileState.data[tileIndex] = result
                    tileState.ping();
                    if (logMessage !== undefined) {
                        logMessages.data.push(logMessage)
                        logMessages.ping();
                    }
                });
        }))


        const statistics = new VariableUiElement(tileState.map(states => {
            let total = 0
            const perResult = new Map<string, number>()
            for (const key in states) {
                total++
                const result = states[key]
                perResult.set(result, (perResult.get(result) ?? 0) + 1)
            }

            let sum = 0
            neededTimes.data.forEach(v => {
                sum = sum + v
            })
            let timePerTile = sum / neededTimes.data.length

            return new Combine(["Handled " + total + "/" + indices.length + " tiles: ",
                new List(Array.from(perResult.keys()).map(key => key + ": " + perResult.get(key))),
                "Handling one tile needs " + (Math.floor(timePerTile * 100) / 100) + "s on average. Estimated time left: " + Utils.toHumanTime((indices.length - total) * timePerTile)
            ]).SetClass("flex flex-col")
        }))

        super([statistics, automaton,
            new SubtleButton(undefined, "Clear fixed").onClick(() => {
                const st = tileState.data
                for (const tileIndex in st) {
                    if (st[tileIndex] === "fixed") {
                        delete st[tileIndex]
                    }
                }

                tileState.ping();
            }),
            new VariableUiElement(logMessages.map(logMessages => new List(logMessages)))])
        this.SetClass("flex flex-col")
    }

    private static TileHandler(layoutToUse: LayoutConfig, tileIndex: number, targetLayer: string, targetAction: TagRenderingConfig, extraCommentText: UIEventSource<string>,
                               whenDone: ((result: string, logMessage?: string) => void)): BaseUIElement {

        const state = new MapState(layoutToUse, {attemptLogin: false})
        extraCommentText.syncWith(state.changes.extraComment)
        const [z, x, y] = Tiles.tile_from_index(tileIndex)
        state.locationControl.setData({
            zoom: z,
            lon: x,
            lat: y
        })
        state.currentBounds.setData(
            BBox.fromTileIndex(tileIndex)
        )

        let targetTiles: UIEventSource<FeatureSource[]> = new UIEventSource<FeatureSource[]>([])
        const pipeline = new FeaturePipeline((tile => {
            const layerId = tile.layer.layerDef.id
            if (layerId === targetLayer) {
                targetTiles.data.push(tile)
                targetTiles.ping()
            }
        }), state)

        state.locationControl.ping();
        state.currentBounds.ping();
        const stateToShow = new UIEventSource("")

        pipeline.runningQuery.map(
            async isRunning => {
                if (targetTiles.data.length === 0) {
                    stateToShow.setData("No data loaded yet...")
                    return;
                }
                if (isRunning) {
                    stateToShow.setData("Waiting for all layers to be loaded... Has " + targetTiles.data.length + " tiles already")
                    return;
                }
                if (targetTiles.data.length === 0) {
                    stateToShow.setData("No features found to apply the action")
                    whenDone("empty")
                    return true;
                }
                stateToShow.setData("Gathering applicable elements")

                let handled = 0
                let inspected = 0
                let log = []
                for (const targetTile of targetTiles.data) {

                    for (const ffs of targetTile.features.data) {
                        inspected++
                        if (inspected % 10 === 0) {
                            stateToShow.setData("Inspected " + inspected + " features, updated " + handled + " features")
                        }
                        const feature = ffs.feature
                        const renderingTr = targetAction.GetRenderValue(feature.properties)
                        const rendering = renderingTr.txt
                        log.push("<a href='https://openstreetmap.org/" + feature.properties.id + "' target='_blank'>" + feature.properties.id + "</a>: " + new SubstitutedTranslation(renderingTr, new UIEventSource<any>(feature.properties), undefined).ConstructElement().textContent)
                        const actions = Utils.NoNull(SubstitutedTranslation.ExtractSpecialComponents(rendering)
                            .map(obj => obj.special))
                        for (const action of actions) {
                            const auto = <AutoAction>action.func
                            if (auto.supportsAutoAction !== true) {
                                continue
                            }

                            await auto.applyActionOn({
                                layoutToUse: state.layoutToUse,
                                changes: state.changes
                            }, state.allElements.getEventSourceById(feature.properties.id), action.args)
                            handled++
                        }
                    }
                }
                stateToShow.setData("Done! Inspected " + inspected + " features, updated " + handled + " features")

                if (inspected === 0) {
                    whenDone("empty")
                    return true;
                }

                if (handled === 0) {
                    whenDone("no-action", "Inspected " + inspected + " elements: " + log.join("; "))
                } else {
                    state.osmConnection.AttemptLogin()
                    state.changes.flushChanges("handled tile automatically, time to flush!")
                    whenDone("fixed", "Updated " + handled + " elements, inspected " + inspected + ": " + log.join("; "))
                }
                return true;

            }, [targetTiles])

        return new Combine([
            new Title("Performing action for tile " + tileIndex, 1),
            new VariableUiElement(stateToShow)]).SetClass("flex flex-col")
    }

}


class AutomatonGui {

    constructor() {

        const osmConnection = new OsmConnection({
            singlePage: false,
            oauth_token: QueryParameters.GetQueryParameter("oauth_token", "OAuth token")
        });

        new Combine([
            new Combine([Svg.robot_svg().SetClass("w-24 h-24 p-4 rounded-full subtle-background"),
                new Combine([new Title("MapComplete Automaton", 1),
                    "This page helps to automate certain tasks for a theme. Expert use only."
                ]).SetClass("flex flex-col m-4")
            ]).SetClass("flex"),
            new Toggle(
                AutomatonGui.GenerateMainPanel(),
                new SubtleButton(Svg.osm_logo_svg(), "Login to get started").onClick(() => osmConnection.AttemptLogin()),
                osmConnection.isLoggedIn
            )]).SetClass("block p-4")
            .AttachTo("main")
    }


    private static GenerateMainPanel(): BaseUIElement {

        const themeSelect = new DropDown<string>("Select a theme",
            Array.from(themeOverview).map(l => ({value: l.id, shown: l.id}))
        )

        LocalStorageSource.Get("automation-theme-id", "missing_streets").syncWith(themeSelect.GetValue())

        const tilepath = ValidatedTextField.ForType("url").ConstructInputElement({
            placeholder: "Specifiy the path of the overview",
            inputStyle: "width: 100%"
        })
        tilepath.SetClass("w-full")
        LocalStorageSource.Get("automation-tile_path").syncWith(tilepath.GetValue(), true)


        let tilesToRunOver = tilepath.GetValue().bind(path => {
            if (path === undefined) {
                return undefined
            }
            return UIEventSource.FromPromiseWithErr(Utils.downloadJsonCached(path, 1000 * 60 * 60))
        })

        const targetZoom = 14

        const tilesPerIndex = tilesToRunOver.map(tiles => {

            if (tiles === undefined || tiles["error"] !== undefined) {
                return undefined
            }
            let indexes: number[] = [];
            const tilesS = tiles["success"]
            DynamicGeoJsonTileSource.RegisterWhitelist(tilepath.GetValue().data, tilesS)
            const z = Number(tilesS["zoom"])
            for (const key in tilesS) {
                if (key === "zoom") {
                    continue
                }
                const x = Number(key)
                const ys = tilesS[key]
                indexes.push(...ys.map(y => Tiles.tile_index(z, x, y)))
            }

            console.log("Got ", indexes.length, "indexes")
            let rezoomed = new Set<number>()
            for (const index of indexes) {
                let [z, x, y] = Tiles.tile_from_index(index)
                while (z > targetZoom) {
                    z--
                    x = Math.floor(x / 2)
                    y = Math.floor(y / 2)
                }
                rezoomed.add(Tiles.tile_index(z, x, y))
            }


            return Array.from(rezoomed)
        })

        const extraComment = ValidatedTextField.ForType("text").ConstructInputElement()
        LocalStorageSource.Get("automaton-extra-comment").syncWith(extraComment.GetValue())

        return new Combine([
            themeSelect,
            "Specify the path to a tile overview. This is a hosted .json of the format {x : [y0, y1, y2], x1: [y0, ...]} where x is a string and y are numbers",
            tilepath,
            "Add an extra comment:",
            extraComment,
            new VariableUiElement(extraComment.GetValue().map(c => "Your comment is " + (c?.length ?? 0) + "/200 characters long")).SetClass("subtle"),
            new VariableUiElement(tilesToRunOver.map(t => {
                if (t === undefined) {
                    return "No path given or still loading..."
                }
                if (t["error"] !== undefined) {
                    return new FixedUiElement("Invalid URL or data: " + t["error"]).SetClass("alert")
                }

                return new FixedUiElement("Loaded " + tilesPerIndex.data.length + " tiles to automated over").SetClass("thanks")
            })),
            new VariableUiElement(themeSelect.GetValue().map(id => AllKnownLayouts.allKnownLayouts.get(id)).map(layoutToUse => {
                if (layoutToUse === undefined) {
                    return new FixedUiElement("Select a valid layout")
                }
                if (tilesPerIndex.data === undefined || tilesPerIndex.data.length === 0) {
                    return "No tiles given"
                }

                const automatableTagRenderings: { layer: LayerConfig, tagRendering: TagRenderingConfig }[] = []
                for (const layer of layoutToUse.layers) {
                    for (const tagRendering of layer.tagRenderings) {
                        if (tagRendering.group === "auto") {
                            automatableTagRenderings.push({layer, tagRendering: tagRendering})
                        }
                    }
                }
                console.log("Automatable tag renderings:", automatableTagRenderings)
                if (automatableTagRenderings.length === 0) {
                    return new FixedUiElement('This theme does not have any tagRendering with "group": "auto" set').SetClass("alert")
                }
                const pickAuto = new DropDown("Pick the action to automate",
                    [
                        {
                            value: undefined,
                            shown: "Pick an option"
                        },
                        ...automatableTagRenderings.map(config => (
                            {
                                shown: config.layer.id + " - " + config.tagRendering.id,
                                value: config
                            }
                        ))
                    ]
                )


                return new Combine([
                    pickAuto,
                    new VariableUiElement(pickAuto.GetValue().map(auto => auto === undefined ? undefined : new AutomationPanel(layoutToUse, tilesPerIndex.data, extraComment.GetValue(), auto)))])

            }, [tilesPerIndex])).SetClass("flex flex-col")


        ]).SetClass("flex flex-col")


    }

}


MinimapImplementation.initialize()

new AutomatonGui()