mapcomplete/Logic/FeatureSource/Actors/SaveTileToLocalStorageActor.ts

import FeatureSource, { Tiled } from "../FeatureSource"
import { Tiles } from "../../../Models/TileRange"
import { IdbLocalStorage } from "../../Web/IdbLocalStorage"
import { UIEventSource } from "../../UIEventSource"
import LayerConfig from "../../../Models/ThemeConfig/LayerConfig"
import { BBox } from "../../BBox"
import SimpleFeatureSource from "../Sources/SimpleFeatureSource"
import FilteredLayer from "../../../Models/FilteredLayer"
import Loc from "../../../Models/Loc"

/***
 * Saves all the features that are passed in to localstorage, so they can be retrieved on the next run
 *
 * Technically, more an Actor then a featuresource, but it fits more neatly this ay
 */
export default class SaveTileToLocalStorageActor {
    private readonly visitedTiles: UIEventSource<Map<number, Date>>
    private readonly _layer: LayerConfig
    private readonly _flayer: FilteredLayer
    private readonly initializeTime = new Date()

    constructor(layer: FilteredLayer) {
        this._flayer = layer
        this._layer = layer.layerDef
        this.visitedTiles = IdbLocalStorage.Get("visited_tiles_" + this._layer.id, {
            defaultValue: new Map<number, Date>(),
        })
        this.visitedTiles.stabilized(100).addCallbackAndRunD((tiles) => {
            for (const key of Array.from(tiles.keys())) {
                const tileFreshness = tiles.get(key)

                const toOld =
                    this.initializeTime.getTime() - tileFreshness.getTime() >
                    1000 * this._layer.maxAgeOfCache
                if (toOld) {
                    // Purge this tile
                    this.SetIdb(key, undefined)
                    console.debug("Purging tile", this._layer.id, key)
                    tiles.delete(key)
                }
            }
            this.visitedTiles.ping()
            return true
        })
    }

    public LoadTilesFromDisk(
        currentBounds: UIEventSource<BBox>,
        location: UIEventSource<Loc>,
        registerFreshness: (tileId: number, freshness: Date) => void,
        registerTile: (src: FeatureSource & Tiled) => void
    ) {
        const self = this
        const loadedTiles = new Set<number>()
        this.visitedTiles.addCallbackD((tiles) => {
            if (tiles.size === 0) {
                // We don't do anything yet as probably not yet loaded from disk
                // We'll unregister later on
                return
            }
            currentBounds.addCallbackAndRunD((bbox) => {
                if (self._layer.minzoomVisible > location.data.zoom) {
                    // Not enough zoom
                    return
                }

                // Iterate over all available keys in the local storage, check which are needed and fresh enough
                for (const key of Array.from(tiles.keys())) {
                    const tileFreshness = tiles.get(key)
                    if (tileFreshness > self.initializeTime) {
                        // This tile is loaded by another source
                        continue
                    }

                    registerFreshness(key, tileFreshness)
                    const tileBbox = BBox.fromTileIndex(key)
                    if (!bbox.overlapsWith(tileBbox)) {
                        continue
                    }
                    if (loadedTiles.has(key)) {
                        // Already loaded earlier
                        continue
                    }
                    loadedTiles.add(key)
                    this.GetIdb(key).then((features: { feature: any; freshness: Date }[]) => {
                        if (features === undefined) {
                            return
                        }
                        console.debug("Loaded tile " + self._layer.id + "_" + key + " from disk")
                        const src = new SimpleFeatureSource(
                            self._flayer,
                            key,
                            new UIEventSource<{ feature: any; freshness: Date }[]>(features)
                        )
                        registerTile(src)
                    })
                }
            })

            return true // Remove the callback
        })
    }

    public addTile(tile: FeatureSource & Tiled) {
        const self = this
        tile.features.addCallbackAndRunD((features) => {
            const now = new Date()

            if (features.length > 0) {
                self.SetIdb(tile.tileIndex, features)
            }
            // We _still_ write the time to know that this tile is empty!
            this.MarkVisited(tile.tileIndex, now)
        })
    }

    public poison(lon: number, lat: number) {
        for (let z = 0; z < 25; z++) {
            const { x, y } = Tiles.embedded_tile(lat, lon, z)
            const tileId = Tiles.tile_index(z, x, y)
            this.visitedTiles.data.delete(tileId)
        }
    }

    public MarkVisited(tileId: number, freshness: Date) {
        this.visitedTiles.data.set(tileId, freshness)
        this.visitedTiles.ping()
    }

    private SetIdb(tileIndex, data) {
        try {
            IdbLocalStorage.SetDirectly(this._layer.id + "_" + tileIndex, data)
        } catch (e) {
            console.error(
                "Could not save tile to indexed-db: ",
                e,
                "tileIndex is:",
                tileIndex,
                "for layer",
                this._layer.id
            )
        }
    }

    private GetIdb(tileIndex) {
        return IdbLocalStorage.GetDirectly(this._layer.id + "_" + tileIndex)
    }
}