mapcomplete/Logic/Actors/OverpassFeatureSource.ts

import {UIEventSource} from "../UIEventSource";
import Loc from "../../Models/Loc";
import {Or} from "../Tags/Or";
import {Overpass} from "../Osm/Overpass";
import Bounds from "../../Models/Bounds";
import FeatureSource, {FeatureSourceState} from "../FeatureSource/FeatureSource";
import {Utils} from "../../Utils";
import {TagsFilter} from "../Tags/TagsFilter";
import SimpleMetaTagger from "../SimpleMetaTagger";
import LayoutConfig from "../../Models/ThemeConfig/LayoutConfig";
import RelationsTracker from "../Osm/RelationsTracker";
import {BBox} from "../BBox";


export default class OverpassFeatureSource implements FeatureSource {

    public readonly name = "OverpassFeatureSource"

    /**
     * The last loaded features of the geojson
     */
    public readonly features: UIEventSource<{ feature: any, freshness: Date }[]> = new UIEventSource<any[]>(undefined);


    public readonly runningQuery: UIEventSource<boolean> = new UIEventSource<boolean>(false);
    public readonly timeout: UIEventSource<number> = new UIEventSource<number>(0);

    public readonly relationsTracker: RelationsTracker;


    private readonly retries: UIEventSource<number> = new UIEventSource<number>(0);
    /**
     * The previous bounds for which the query has been run at the given zoom level
     *
     * Note that some layers only activate on a certain zoom level.
     * If the map location changes, we check for each layer if it is loaded:
     * we start checking the bounds at the first zoom level the layer might operate. If in bounds - no reload needed, otherwise we continue walking down
     */
    private readonly _previousBounds: Map<number, Bounds[]> = new Map<number, Bounds[]>();
    private readonly state: {
        readonly locationControl: UIEventSource<Loc>,
        readonly layoutToUse: UIEventSource<LayoutConfig>,
        readonly overpassUrl: UIEventSource<string>;
        readonly overpassTimeout: UIEventSource<number>;
        readonly currentBounds :UIEventSource<BBox>
    }
    private readonly _isActive: UIEventSource<boolean>;
    private _onUpdated?: (bbox: BBox, dataFreshness: Date) => void;
    /**
     * The most important layer should go first, as that one gets first pick for the questions
     */
    constructor(
        state: {
            readonly locationControl: UIEventSource<Loc>,
            readonly layoutToUse: UIEventSource<LayoutConfig>,
            readonly overpassUrl: UIEventSource<string>;
            readonly overpassTimeout: UIEventSource<number>;
            readonly overpassMaxZoom: UIEventSource<number>,
            readonly currentBounds :UIEventSource<BBox>
        },   
        
       options?: {
            isActive?: UIEventSource<boolean>,
           onUpdated?:  (bbox: BBox, freshness: Date) => void,
       relationTracker: RelationsTracker}) {

        this.state = state
        this._isActive = options.isActive;
        this._onUpdated =options. onUpdated;
        this.relationsTracker = options.relationTracker
        const location = state.locationControl
        const self = this;

        for (let i = 0; i < 25; i++) {
            // This update removes all data on all layers -> erase the map on lower levels too
            this._previousBounds.set(i, []);
        }

        state.layoutToUse.addCallback(() => {
            self.update()
        });
        location.addCallback(() => {
            self.update()
        });
        
        state.currentBounds.addCallback(_ => {
            self.update()
        })
       
    }

    private GetFilter(): Overpass {
        let filters: TagsFilter[] = [];
        let extraScripts: string[] = [];
        for (const layer of this.state.layoutToUse.data.layers) {
            if (typeof (layer) === "string") {
                throw "A layer was not expanded!"
            }
            if (this.state.locationControl.data.zoom < layer.minzoom) {
                continue;
            }
            if (layer.doNotDownload) {
                continue;
            }
            if (layer.source.geojsonSource !== undefined) {
                // Not our responsibility to download this layer!
                continue;
            }


            // Check if data for this layer has already been loaded
            let previouslyLoaded = false;
            for (let z = layer.minzoom; z < 25 && !previouslyLoaded; z++) {
                const previousLoadedBounds = this._previousBounds.get(z);
                if (previousLoadedBounds === undefined) {
                    continue;
                }
                for (const previousLoadedBound of previousLoadedBounds) {
                    previouslyLoaded = previouslyLoaded || this.IsInBounds(previousLoadedBound);
                    if (previouslyLoaded) {
                        break;
                    }
                }
            }
            if (previouslyLoaded) {
                continue;
            }
            if (layer.source.overpassScript !== undefined) {
                extraScripts.push(layer.source.overpassScript)
            } else {
                filters.push(layer.source.osmTags);
            }
        }
        filters = Utils.NoNull(filters)
        extraScripts = Utils.NoNull(extraScripts)
        if (filters.length + extraScripts.length === 0) {
            return undefined;
        }
        return new Overpass(new Or(filters), extraScripts, this.state.overpassUrl, this.state.overpassTimeout, this.relationsTracker);
    }

    private update() {
        if(!this._isActive.data){
            return;
        }
        const self = this
        this.updateAsync().then(bboxAndDate => {
            if(bboxAndDate === undefined || self._onUpdated === undefined){
                return;
            }
            const [bbox, date] = bboxAndDate
            self._onUpdated(bbox, date);
        })
    }

    private async updateAsync(): Promise<[BBox, Date]> {
        if (this.runningQuery.data) {
            console.log("Still running a query, not updating");
            return undefined;
        }

        if (this.timeout.data > 0) {
            console.log("Still in timeout - not updating")
            return undefined;
        }

        const bounds = this.state.currentBounds.data?.pad(this.state.layoutToUse.data.widenFactor)?.expandToTileBounds(14);
        
        if (bounds === undefined) {
            return undefined;
        }

        const n = Math.min(90, bounds.getNorth());
        const e = Math.min(180, bounds.getEast());
        const s = Math.max(-90, bounds.getSouth());
        const w = Math.max(-180, bounds.getWest());
        const queryBounds = {north: n, east: e, south: s, west: w};


        const self = this;
        const overpass = this.GetFilter();

        if (overpass === undefined) {
            return undefined;
        }
        this.runningQuery.setData(true);

        let data: any = undefined
        let date: Date = undefined

        do {

            try {
                [data, date] = await overpass.queryGeoJson(queryBounds)
                console.log("Querying overpass is done", data)
            } catch (e) {
                self.retries.data++;
                self.retries.ping();
                console.error(`QUERY FAILED (retrying in ${5 * self.retries.data} sec) due to`, e);

                self.timeout.setData(self.retries.data * 5);
                
                while (self.timeout.data > 0) {
                    await Utils.waitFor(1000)
                    self.timeout.data--
                    self.timeout.ping();
                }
            }
        } while (data === undefined);

        const z = Math.floor(this.state.locationControl.data.zoom ?? 0);
        self._previousBounds.get(z).push(queryBounds);
        self.retries.setData(0);

        try {
            data.features.forEach(feature => SimpleMetaTagger.objectMetaInfo.applyMetaTagsOnFeature(feature, date));
            self.features.setData(data.features.map(f => ({feature: f, freshness: date})));
            return [bounds, date];
        } catch (e) {
            console.error("Got the overpass response, but could not process it: ", e, e.stack)
        }finally {
            self.runningQuery.setData(false);
        }
        


    }

    private IsInBounds(bounds: Bounds): boolean {
        if (this._previousBounds === undefined) {
            return false;
        }

        const b = this.state.currentBounds.data;
        return b.getSouth() >= bounds.south &&
            b.getNorth() <= bounds.north &&
            b.getEast() <= bounds.east &&
            b.getWest() >= bounds.west;
    }


}