import FeaturePipelineState from "../Logic/State/FeaturePipelineState";
import MinimapImplementation from "../UI/Base/MinimapImplementation";
import {UIEventSource} from "../Logic/UIEventSource";
import Loc from "../Models/Loc";
import ShowDataLayer from "../UI/ShowDataLayer/ShowDataLayer";
import {BBox} from "../Logic/BBox";
import Minimap from "../UI/Base/Minimap";
import AvailableBaseLayers from "../Logic/Actors/AvailableBaseLayers";
import {Utils} from "../Utils";

export interface PngMapCreatorOptions{
    readonly divId: string; readonly width: number; readonly height: number; readonly scaling?: 1 | number,
    readonly dummyMode?: boolean
}

export class PngMapCreator {
    private readonly _state: FeaturePipelineState | undefined;
    private readonly _options: PngMapCreatorOptions;

    constructor(state: FeaturePipelineState | undefined, options: PngMapCreatorOptions) {
        this._state = state;
        this._options = {...options, scaling: options.scaling ?? 1};
    }

    /**
     * Creates a minimap, waits till all needed tiles are loaded before returning
     * @private
     */
    private async createAndLoadMinimap(): Promise<MinimapImplementation> {
        const state = this._state;
        const options = this._options
        const baselayer = AvailableBaseLayers.layerOverview.find(bl => bl.id === state.layoutToUse.defaultBackgroundId) ?? AvailableBaseLayers.osmCarto
        return new Promise(resolve => {
            const minimap = Minimap.createMiniMap({
                location: new UIEventSource<Loc>(state.locationControl.data), // We remove the link between the old and the new UI-event source as moving the map while the export is running fucks up the screenshot
                background: new UIEventSource(baselayer),
                allowMoving: false,
                onFullyLoaded: (_) =>
                    window.setTimeout(() => {
                        resolve(<MinimapImplementation>minimap)
                    }, 250)
            })
            const style = `width: ${options.width * options.scaling}mm; height: ${options.height * options.scaling}mm;`
            minimap.SetStyle(style)
            minimap.AttachTo(options.divId)
        })

    }

    /**
     * Creates a base64-encoded PNG image
     * @constructor
     */
    public async CreatePng(format: "image" ): Promise<string > ;
    public async CreatePng(format: "blob"): Promise<Blob> ;
    public async CreatePng(format: "image" | "blob"): Promise<string | Blob>;
    public async CreatePng(format: "image" | "blob"): Promise<string | Blob> {

        // Lets first init the minimap and wait for all background tiles to load
        const minimap = await this.createAndLoadMinimap()
        const state = this._state
        const dummyMode = this._options.dummyMode ?? false
        return new Promise<string | Blob>((resolve, reject) => {
            // Next: we prepare the features. Only fully contained features are shown
            minimap.leafletMap.addCallbackAndRunD(async (leaflet) => {
                // Ping the featurepipeline to download what is needed
                if (dummyMode) {
                    console.warn("Dummy mode is active - not loading map layers")
                } else {
                    const bounds = BBox.fromLeafletBounds(leaflet.getBounds().pad(0.1).pad(-state.layoutToUse.widenFactor))
                    state.currentBounds.setData(bounds)
                    if(!state.featurePipeline.sufficientlyZoomed.data){
                        console.warn("Not sufficiently zoomed!")
                    }

                    if (state.featurePipeline.runningQuery.data) {
                        // A query is running!
                        // Let's wait for it to complete
                        console.log("Waiting for the query to complete")
                        await state.featurePipeline.runningQuery.AsPromise(isRunning => !isRunning)
                        console.log("Query has completeted!")
                    }

                    state.featurePipeline.GetTilesPerLayerWithin(bounds, (tile) => {
                        if (tile.layer.layerDef.id.startsWith("note_import")) {
                            // Don't export notes to import
                            return
                        }
                        new ShowDataLayer({
                            features: tile,
                            leafletMap: minimap.leafletMap,
                            layerToShow: tile.layer.layerDef,
                            doShowLayer: tile.layer.isDisplayed,
                            state: undefined,
                        })
                    })
                    await Utils.waitFor(2000)
                }
                minimap.TakeScreenshot(format).then(async result => {
                    const divId = this._options.divId
                    await Utils.waitFor(250)
                    document.getElementById(divId).removeChild(/*Will fetch the cached htmlelement:*/minimap.ConstructElement())
                    return resolve(result);
                }).catch(failreason => {
                    console.error("Could no make a screenshot due to ",failreason)
                    reject(failreason)
                })
            })

            state.AddAllOverlaysToMap(minimap.leafletMap)
        })
    }
}