import FeatureSource, {FeatureSourceForLayer, Tiled} from "../../Logic/FeatureSource/FeatureSource";
import LayerConfig from "../../Models/ThemeConfig/LayerConfig";
import {UIEventSource} from "../../Logic/UIEventSource";
import {Tiles} from "../../Models/TileRange";
import StaticFeatureSource from "../../Logic/FeatureSource/Sources/StaticFeatureSource";
import {BBox} from "../../Logic/BBox";
import FilteredLayer from "../../Models/FilteredLayer";

/**
 * A feature source containing but a single feature, which keeps stats about a tile
 */
export class TileHierarchyAggregator implements FeatureSource {
    private static readonly empty = []
    public totalValue: number = 0
    public showCount: number = 0
    public hiddenCount: number = 0
    public readonly features = new UIEventSource<{ feature: any, freshness: Date }[]>(TileHierarchyAggregator.empty)
    public readonly name;
    private _parent: TileHierarchyAggregator;
    private _root: TileHierarchyAggregator;
    private _z: number;
    private _x: number;
    private _y: number;
    private _tileIndex: number
    private _counter: SingleTileCounter
    private _subtiles: [TileHierarchyAggregator, TileHierarchyAggregator, TileHierarchyAggregator, TileHierarchyAggregator] = [undefined, undefined, undefined, undefined]
    private readonly featuresStatic = []
    private readonly featureProperties: { count: string, kilocount: string, tileId: string, id: string, showCount: string, totalCount: string };
    private readonly _state: { filteredLayers: UIEventSource<FilteredLayer[]> };
    private readonly updateSignal = new UIEventSource<any>(undefined)

    private constructor(parent: TileHierarchyAggregator,
                        state: {
                            filteredLayers: UIEventSource<FilteredLayer[]>
                        },
                        z: number, x: number, y: number) {
        this._parent = parent;
        this._state = state;
        this._root = parent?._root ?? this
        this._z = z;
        this._x = x;
        this._y = y;
        this._tileIndex = Tiles.tile_index(z, x, y)
        this.name = "Count(" + this._tileIndex + ")"

        const totals = {
            id: "" + this._tileIndex,
            tileId: "" + this._tileIndex,
            count: `0`,
            kilocount: "0",
            showCount: "0",
            totalCount: "0"
        }
        this.featureProperties = totals

        const now = new Date()
        const feature = {
            "type": "Feature",
            "properties": totals,
            "geometry": {
                "type": "Point",
                "coordinates": Tiles.centerPointOf(z, x, y)
            }
        }
        this.featuresStatic.push({feature: feature, freshness: now})

        const bbox = BBox.fromTile(z, x, y)
        const box = {
            "type": "Feature",
            "properties": totals,
            "geometry": {
                "type": "Polygon",
                "coordinates": [
                    [
                        [bbox.minLon, bbox.minLat],
                        [bbox.minLon, bbox.maxLat],
                        [bbox.maxLon, bbox.maxLat],
                        [bbox.maxLon, bbox.minLat],
                        [bbox.minLon, bbox.minLat]
                    ]
                ]
            }
        }
        this.featuresStatic.push({feature: box, freshness: now})
    }

    public static createHierarchy(state: { filteredLayers: UIEventSource<FilteredLayer[]> }) {
        return new TileHierarchyAggregator(undefined, state, 0, 0, 0)
    }

    public getTile(tileIndex): TileHierarchyAggregator {
        if (tileIndex === this._tileIndex) {
            return this;
        }
        let [tileZ, tileX, tileY] = Tiles.tile_from_index(tileIndex)
        while (tileZ - 1 > this._z) {
            tileX = Math.floor(tileX / 2)
            tileY = Math.floor(tileY / 2)
            tileZ--
        }
        const xDiff = tileX - (2 * this._x)
        const yDiff = tileY - (2 * this._y)
        const subtileIndex = yDiff * 2 + xDiff;
        return this._subtiles[subtileIndex]?.getTile(tileIndex)
    }

    public addTile(source: FeatureSourceForLayer & Tiled) {
        const self = this;
        if (source.tileIndex === this._tileIndex) {
            if (this._counter === undefined) {
                this._counter = new SingleTileCounter(this._tileIndex)
                this._counter.countsPerLayer.addCallbackAndRun(_ => self.update())
            }
            this._counter.addTileCount(source)
        } else {

            // We have to give it to one of the subtiles
            let [tileZ, tileX, tileY] = Tiles.tile_from_index(source.tileIndex)
            while (tileZ - 1 > this._z) {
                tileX = Math.floor(tileX / 2)
                tileY = Math.floor(tileY / 2)
                tileZ--
            }
            const xDiff = tileX - (2 * this._x)
            const yDiff = tileY - (2 * this._y)

            const subtileIndex = yDiff * 2 + xDiff;
            if (this._subtiles[subtileIndex] === undefined) {
                this._subtiles[subtileIndex] = new TileHierarchyAggregator(this, this._state, tileZ, tileX, tileY)
            }
            this._subtiles[subtileIndex].addTile(source)
        }
        this.updateSignal.setData(source)
    }

    getCountsForZoom(clusteringConfig: { maxZoom: number }, locationControl: UIEventSource<{ zoom: number }>, cutoff: number = 0): FeatureSource {
        const self = this
        const empty = []
        const features = locationControl.map(loc => loc.zoom).map(targetZoom => {
            if (targetZoom - 1 > clusteringConfig.maxZoom) {
                return empty
            }

            const features: {feature: any, freshness: Date}[] = []
            self.visitSubTiles(aggr => {
                if (aggr.showCount < cutoff) {
                    return false
                }
                if (aggr._z === targetZoom) {
                    features.push(...aggr.features.data)
                    return false
                }
                return aggr._z <= targetZoom;
            })

            return features
        }, [this.updateSignal.stabilized(500)])

        return new StaticFeatureSource(features);
    }

    private update() {
        const newMap = new Map<string, number>()
        let total = 0
        let hiddenCount = 0
        let showCount = 0
        let isShown: Map<string, FilteredLayer> = new Map<string, FilteredLayer>()
        for (const filteredLayer of this._state.filteredLayers.data) {
            isShown.set(filteredLayer.layerDef.id, filteredLayer)
        }
        this?._counter?.countsPerLayer?.data?.forEach((count, layerId) => {
            newMap.set("layer:" + layerId, count)
            total += count
            this.featureProperties["direct_layer:" + layerId] = count
            const flayer = isShown.get(layerId)
            if (flayer.isDisplayed.data && this._z >= flayer.layerDef.minzoom) {
                showCount += count
            } else {
                hiddenCount += count;
            }
        })


        for (const tile of this._subtiles) {
            if (tile === undefined) {
                continue;
            }
            total += tile.totalValue

            showCount += tile.showCount
            hiddenCount += tile.hiddenCount

            for (const key in tile.featureProperties) {
                if (key.startsWith("layer:")) {
                    newMap.set(key, (newMap.get(key) ?? 0) + Number(tile.featureProperties[key] ?? 0))
                }
            }
        }

        this.totalValue = total
        this.showCount = showCount
        this.hiddenCount = hiddenCount
        this._parent?.update()

        if (total === 0) {
            this.features.setData(TileHierarchyAggregator.empty)
        } else {
            this.featureProperties.count = "" + total;
            this.featureProperties.kilocount = "" + Math.floor(total / 1000);
            this.featureProperties.showCount = "" + showCount
            this.featureProperties.totalCount = "" + total
            newMap.forEach((value, key) => {
                this.featureProperties[key] = "" + value
            })

            this.features.data = this.featuresStatic
            this.features.ping()
        }
    }

    private visitSubTiles(f: (aggr: TileHierarchyAggregator) => boolean) {
        const visitFurther = f(this)
        if (visitFurther) {
            this._subtiles.forEach(tile => tile?.visitSubTiles(f))
        }
    }
}

/**
 * Keeps track of a single tile
 */
class SingleTileCounter implements Tiled {
    public readonly bbox: BBox;
    public readonly tileIndex: number;
    public readonly countsPerLayer: UIEventSource<Map<string, number>> = new UIEventSource<Map<string, number>>(new Map<string, number>())
    public readonly z: number
    public readonly x: number
    public readonly y: number
    private readonly registeredLayers: Map<string, LayerConfig> = new Map<string, LayerConfig>();

    constructor(tileIndex: number) {
        this.tileIndex = tileIndex
        this.bbox = BBox.fromTileIndex(tileIndex)
        const [z, x, y] = Tiles.tile_from_index(tileIndex)
        this.z = z;
        this.x = x;
        this.y = y
    }

    public addTileCount(source: FeatureSourceForLayer) {
        const layer = source.layer.layerDef
        this.registeredLayers.set(layer.id, layer)
        const self = this
        source.features.map(f => {
            const isDisplayed = source.layer.isDisplayed.data
            self.countsPerLayer.data.set(layer.id, isDisplayed ? f.length : 0)
            self.countsPerLayer.ping()
        }, [source.layer.isDisplayed])
    }

}