import { Utils } from "../../Utils"
import BaseUIElement from "../BaseUIElement"
import { UIEventSource } from "../../Logic/UIEventSource"
import Loc from "../../Models/Loc"
import BaseLayer from "../../Models/BaseLayer"
import AvailableBaseLayers from "../../Logic/Actors/AvailableBaseLayers"
import * as L from "leaflet"
import { LeafletMouseEvent, Map } from "leaflet"
import Minimap, { MinimapObj, MinimapOptions } from "./Minimap"
import { BBox } from "../../Logic/BBox"
import "leaflet-polylineoffset"
import { SimpleMapScreenshoter } from "leaflet-simple-map-screenshoter"
import BackgroundMapSwitch from "../BigComponents/BackgroundMapSwitch"
import AvailableBaseLayersImplementation from "../../Logic/Actors/AvailableBaseLayersImplementation"
import ShowDataLayer from "../ShowDataLayer/ShowDataLayer"
import ShowDataLayerImplementation from "../ShowDataLayer/ShowDataLayerImplementation"
import FilteredLayer from "../../Models/FilteredLayer"
import ScrollableFullScreen from "./ScrollableFullScreen"
import Constants from "../../Models/Constants"
import StrayClickHandler from "../../Logic/Actors/StrayClickHandler"

/**
 * The stray-click-hanlders adds a marker to the map if no feature was clicked.
 * Shows the given uiToShow-element in the messagebox
 */
export class StrayClickHandlerImplementation {
    private _lastMarker

    constructor(
        state: {
            LastClickLocation: UIEventSource<{ lat: number; lon: number }>
            selectedElement: UIEventSource<string>
            filteredLayers: UIEventSource<FilteredLayer[]>
            leafletMap: UIEventSource<L.Map>
        },
        uiToShow: ScrollableFullScreen,
        iconToShow: BaseUIElement
    ) {
        const self = this
        const leafletMap = state.leafletMap
        state.filteredLayers.data.forEach((filteredLayer) => {
            filteredLayer.isDisplayed.addCallback((isEnabled) => {
                if (isEnabled && self._lastMarker && leafletMap.data !== undefined) {
                    // When a layer is activated, we remove the 'last click location' in order to force the user to reclick
                    // This reclick might be at a location where a feature now appeared...
                    state.leafletMap.data.removeLayer(self._lastMarker)
                }
            })
        })

        state.LastClickLocation.addCallback(function (lastClick) {
            if (self._lastMarker !== undefined) {
                state.leafletMap.data?.removeLayer(self._lastMarker)
            }

            if (lastClick === undefined) {
                return
            }

            state.selectedElement.setData(undefined)
            const clickCoor: [number, number] = [lastClick.lat, lastClick.lon]
            self._lastMarker = L.marker(clickCoor, {
                icon: L.divIcon({
                    html: iconToShow.ConstructElement(),
                    iconSize: [50, 50],
                    iconAnchor: [25, 50],
                    popupAnchor: [0, -45],
                }),
            })

            self._lastMarker.addTo(leafletMap.data)

            self._lastMarker.on("click", () => {
                if (leafletMap.data.getZoom() < Constants.userJourney.minZoomLevelToAddNewPoints) {
                    leafletMap.data.flyTo(
                        clickCoor,
                        Constants.userJourney.minZoomLevelToAddNewPoints
                    )
                    return
                }

                uiToShow.Activate()
            })
        })

        state.selectedElement.addCallback(() => {
            if (self._lastMarker !== undefined) {
                leafletMap.data.removeLayer(self._lastMarker)
                this._lastMarker = undefined
            }
        })
    }
}
export default class MinimapImplementation extends BaseUIElement implements MinimapObj {
    private static _nextId = 0
    public readonly leafletMap: UIEventSource<Map>
    public readonly location: UIEventSource<Loc>
    public readonly bounds: UIEventSource<BBox> | undefined
    private readonly _id: string
    private readonly _background: UIEventSource<BaseLayer>
    private _isInited = false
    private _allowMoving: boolean
    private readonly _leafletoptions: any
    private readonly _onFullyLoaded: (leaflet: L.Map) => void
    private readonly _attribution: BaseUIElement | boolean
    private readonly _addLayerControl: boolean
    private readonly _options: MinimapOptions

    private constructor(options?: MinimapOptions) {
        super()
        options = options ?? {}
        this._id = "minimap" + MinimapImplementation._nextId
        MinimapImplementation._nextId++
        this.leafletMap = options.leafletMap ?? new UIEventSource<Map>(undefined)
        this._background =
            options?.background ?? new UIEventSource<BaseLayer>(AvailableBaseLayers.osmCarto)
        this.location = options?.location ?? new UIEventSource<Loc>({ lat: 0, lon: 0, zoom: 1 })
        this.bounds = options?.bounds
        this._allowMoving = options.allowMoving ?? true
        this._leafletoptions = options.leafletOptions ?? {}
        this._onFullyLoaded = options.onFullyLoaded
        this._attribution = options.attribution
        this._addLayerControl = options.addLayerControl ?? false
        this._options = options
        this.SetClass("relative")
    }

    public static initialize() {
        AvailableBaseLayers.implement(new AvailableBaseLayersImplementation())
        Minimap.createMiniMap = (options) => new MinimapImplementation(options)
        ShowDataLayer.actualContstructor = (options) => new ShowDataLayerImplementation(options)
        StrayClickHandler.construct = (
            state: {
                LastClickLocation: UIEventSource<{ lat: number; lon: number }>
                selectedElement: UIEventSource<string>
                filteredLayers: UIEventSource<FilteredLayer[]>
                leafletMap: UIEventSource<L.Map>
            },
            uiToShow: ScrollableFullScreen,
            iconToShow: BaseUIElement
        ) => {
            return new StrayClickHandlerImplementation(state, uiToShow, iconToShow)
        }
    }

    public installBounds(factor: number | BBox, showRange?: boolean) {
        this.leafletMap.addCallbackD((leaflet) => {
            let bounds: { getEast(); getNorth(); getWest(); getSouth() }
            if (typeof factor === "number") {
                const lbounds = leaflet.getBounds().pad(factor)
                leaflet.setMaxBounds(lbounds)
                bounds = lbounds
            } else {
                // @ts-ignore
                leaflet.setMaxBounds(factor.toLeaflet())
                bounds = factor
            }

            if (showRange) {
                const data = {
                    type: "FeatureCollection",
                    features: [
                        {
                            type: "Feature",
                            geometry: {
                                type: "LineString",
                                coordinates: [
                                    [bounds.getEast(), bounds.getNorth()],
                                    [bounds.getWest(), bounds.getNorth()],
                                    [bounds.getWest(), bounds.getSouth()],

                                    [bounds.getEast(), bounds.getSouth()],
                                    [bounds.getEast(), bounds.getNorth()],
                                ],
                            },
                        },
                    ],
                }
                // @ts-ignore
                L.geoJSON(data, {
                    style: {
                        color: "#f44",
                        weight: 4,
                        opacity: 0.7,
                    },
                }).addTo(leaflet)
            }
        })
    }

    Destroy() {
        super.Destroy()
        console.warn("Decomissioning minimap", this._id)
        const mp = this.leafletMap.data
        this.leafletMap.setData(null)
        mp.off()
        mp.remove()
    }

    /**
     * Takes a screenshot of the current map
     * @param format: image: give a base64 encoded png image;
     * @constructor
     */
    public async TakeScreenshot(): Promise<string>
    public async TakeScreenshot(format: "image"): Promise<string>
    public async TakeScreenshot(format: "blob"): Promise<Blob>
    public async TakeScreenshot(format: "image" | "blob"): Promise<string | Blob>
    public async TakeScreenshot(format: "image" | "blob" = "image"): Promise<string | Blob> {
        console.log("Taking a screenshot...")
        const screenshotter = new SimpleMapScreenshoter()
        screenshotter.addTo(this.leafletMap.data)
        const result = <any>await screenshotter.takeScreen(<any>format ?? "image")
        if (format === "image" && typeof result === "string") {
            return result
        }
        if (format === "blob" && result instanceof Blob) {
            return result
        }
        throw "Something went wrong while creating the screenshot: " + result
    }

    protected InnerConstructElement(): HTMLElement {
        const div = document.createElement("div")
        div.id = this._id
        div.style.height = "100%"
        div.style.width = "100%"
        div.style.minWidth = "40px"
        div.style.minHeight = "40px"
        div.style.position = "relative"
        const wrapper = document.createElement("div")
        wrapper.appendChild(div)
        const self = this
        // @ts-ignore
        const resizeObserver = new ResizeObserver((_) => {
            if (wrapper.clientHeight === 0 || wrapper.clientWidth === 0) {
                return
            }
            if (
                wrapper.offsetParent === null ||
                window.getComputedStyle(wrapper).display === "none"
            ) {
                // Not visible
                return
            }
            try {
                self.InitMap()
            } catch (e) {
                console.debug("Could not construct a minimap:", e)
            }

            try {
                self.leafletMap?.data?.invalidateSize()
            } catch (e) {
                console.debug("Could not invalidate size of a minimap:", e)
            }
        })

        resizeObserver.observe(div)

        if (this._addLayerControl) {
            const switcher = new BackgroundMapSwitch(
                {
                    locationControl: this.location,
                    backgroundLayer: this._background,
                },
                this._background
            ).SetClass("top-0 right-0 z-above-map absolute")
            wrapper.appendChild(switcher.ConstructElement())
        }

        return wrapper
    }

    private InitMap() {
        if (this._constructedHtmlElement === undefined) {
            // This element isn't initialized yet
            return
        }

        if (document.getElementById(this._id) === null) {
            // not yet attached, we probably got some other event
            return
        }

        if (this._isInited) {
            return
        }
        this._isInited = true
        const location = this.location
        const self = this
        let currentLayer = this._background.data.layer()
        let latLon = <[number, number]>[location.data?.lat ?? 0, location.data?.lon ?? 0]
        if (isNaN(latLon[0]) || isNaN(latLon[1])) {
            latLon = [0, 0]
        }
        const options = {
            center: latLon,
            zoom: location.data?.zoom ?? 2,
            layers: [currentLayer],
            zoomControl: false,
            attributionControl: this._attribution !== undefined,
            dragging: this._allowMoving,
            scrollWheelZoom: this._allowMoving,
            doubleClickZoom: this._allowMoving,
            keyboard: this._allowMoving,
            touchZoom: this._allowMoving,
            // Disabling this breaks the geojson layer - don't ask me why!  zoomAnimation: this._allowMoving,
            fadeAnimation: this._allowMoving,
            maxZoom: 21,
        }

        Utils.Merge(this._leafletoptions, options)
        /*
         * Somehow, the element gets '_leaflet_id' set on chrome.
         * When attempting to init this leaflet map, it'll throw an exception and the map won't show up.
         * Simply removing '_leaflet_id' fixes the issue.
         * See https://github.com/pietervdvn/MapComplete/issues/726
         * */
        delete document.getElementById(this._id)["_leaflet_id"]

        const map = L.map(this._id, options)
        if (self._onFullyLoaded !== undefined) {
            currentLayer.on("load", () => {
                console.log("Fully loaded all tiles!")
                self._onFullyLoaded(map)
            })
        }

        // Users are not allowed to zoom to the 'copies' on the left and the right, stuff goes wrong then
        // We give a bit of leeway for people on the edges
        // Also see: https://www.reddit.com/r/openstreetmap/comments/ih4zzc/mapcomplete_a_new_easytouse_editor/g31ubyv/

        map.setMaxBounds([
            [-100, -200],
            [100, 200],
        ])

        if (this._attribution !== undefined) {
            if (this._attribution === true) {
                map.attributionControl.setPrefix(false)
            } else {
                map.attributionControl.setPrefix("<span id='leaflet-attribution'></span>")
            }
        }

        this._background.addCallbackAndRun((layer) => {
            const newLayer = layer.layer()
            if (currentLayer !== undefined) {
                map.removeLayer(currentLayer)
            }
            currentLayer = newLayer
            if (self._onFullyLoaded !== undefined) {
                currentLayer.on("load", () => {
                    console.log("Fully loaded all tiles!")
                    self._onFullyLoaded(map)
                })
            }
            map.addLayer(newLayer)
            if (self._attribution !== true && self._attribution !== false) {
                self._attribution?.AttachTo("leaflet-attribution")
            }
        })

        let isRecursing = false
        map.on("moveend", function () {
            if (isRecursing) {
                return
            }
            if (
                map.getZoom() === location.data.zoom &&
                map.getCenter().lat === location.data.lat &&
                map.getCenter().lng === location.data.lon
            ) {
                return
            }
            location.data.zoom = map.getZoom()
            location.data.lat = map.getCenter().lat
            location.data.lon = map.getCenter().lng
            isRecursing = true
            location.ping()

            if (self.bounds !== undefined) {
                self.bounds.setData(BBox.fromLeafletBounds(map.getBounds()))
            }

            isRecursing = false // This is ugly, I know
        })

        location.addCallback((loc) => {
            const mapLoc = map.getCenter()
            const dlat = Math.abs(loc.lat - mapLoc[0])
            const dlon = Math.abs(loc.lon - mapLoc[1])

            if (dlat < 0.000001 && dlon < 0.000001 && map.getZoom() === loc.zoom) {
                return
            }
            map.setView([loc.lat, loc.lon], loc.zoom)
        })

        if (self.bounds !== undefined) {
            self.bounds.setData(BBox.fromLeafletBounds(map.getBounds()))
        }

        if (this._options.lastClickLocation) {
            const lastClickLocation = this._options.lastClickLocation
            map.addEventListener("click", function (e: LeafletMouseEvent) {
                if (e.originalEvent["dismissed"]) {
                    return
                }
                lastClickLocation?.setData({ lat: e.latlng.lat, lon: e.latlng.lng })
            })

            map.on("contextmenu", function (e) {
                // @ts-ignore
                lastClickLocation?.setData({ lat: e.latlng.lat, lon: e.latlng.lng })
                map.setZoom(map.getZoom() + 1)
            })
        }

        this.leafletMap.setData(map)
    }
}