import Tile from './tile.js'

/**
 * A Tile Loader component that can be plugged into a Tiles Layer.
 */
export class TileLoader {
    constructor(tiles) {
        this.debug = false
        this.tiles = tiles
        this.setup()
    }

    /** Setup collections and instance vars. */
    setup() {
        this.map = new Map() // Map {url : [ col, row]}
        this.loading = new Set() // Set url
        this.loaded = new Map() // Map {url : sprite }
        this.loadQueue = []
    }

    /** Schedules a tile url for loading. The loading itself must be triggered
    by a call to loadOneTile or loadAll

    * @param {String} url - the url of the texture / tile
    * @param {Number} col - the tile col
    * @param {Number} row - the tile row
    **/
    schedule(url, col, row) {
        if (this.loaded.has(url)) return false
        if (this.loading.has(url)) return false

        //Tile.schedule(url)
        this.map.set(url, [col, row])
        this.loading.add(url)
        this.loadQueue.push(url)
        return true
    }

    unschedule(url) {
        if (this.loaded.has(url)) this.loaded.delete(url)
        if (this.loading.has(url)) this.loading.delete(url)
        //Tile.unschedule(url)
        this.loadQueue = this.loadQueue.filter(item => item != url)
    }

    /** Cancels loading by clearing the load queue **/
    cancel() {
        this.loadQueue = []
        this.loading.clear()
    }

    /** Destroys alls collections. **/
    destroy() {
        this.setup()
    }

    /** Private method. Informs the tile layer about a texture for a given url.
     * Creates the sprite for the loaded texture and informs the tile layer.
     * @param {String} url - the url
     * @param {Object} texture - the loaded resource
     **/
    _textureAvailable(url, col, row, texture) {
        let tile = this.loaded.get(url)
        if (tile != null) {
            console.warn('Tile already loaded')
            tile.unregister()
        }
        try {
            tile = new Tile(texture, url)
            this.loaded.set(url, tile)
            this.tiles.tileAvailable(tile, col, row, url)
        } catch (error) {
            console.warn('Tile loading error', error)
        }
    }
}

/**
 * Uses the PIXI Loader but can be replaced with othe loaders implementing
 * the public methods without underscore.
 * Calls the Tiles.tileAvailable method if the texture is available.
 **/
export class PIXITileLoader extends TileLoader {
    constructor(tiles, compression) {
        super(tiles)
        this.destroyed = false
        this.loader = new PIXI.Loader()
        this.loader.onLoad.add(this._onLoaded.bind(this))
        this.loader.onError.add(this._onError.bind(this))
        if (compression) {
            this.loader.use(PIXI.compressedTextures.ImageParser.use)
        }
    }

    schedule(url, col, row) {
        // Overwritten schedule to avoid BaseTexture and Texture already loaded errors.
        if (this.loaded.has(url)) return false
        if (this.loading.has(url)) return false

        //Tile.schedule(url)
        let reusableTexture = Tile.textureAvailable(url)
        if (reusableTexture) {
            if (this.debug) console.log('Texture reusable', reusableTexture)
            this._textureAvailable(url, col, row, reusableTexture)
            return false
        }
        let texture = PIXI.utils.TextureCache[url]
        if (texture) {
            if (this.debug) console.log('Texture already loaded', texture)
            this._textureAvailable(url, col, row, texture)
            return false
        }
        let base = PIXI.utils.BaseTextureCache[url]
        if (base) {
            if (this.debug) console.log('BaseTexture already loaded', base)
            let texture = new PIXI.Texture(base)
            this._textureAvailable(url, col, row, texture)
            return false
        }
        return super.schedule(url, col, row)
    }

    /** Load one and only one of the scheduled tiles **/
    loadOneTile() {
        if (this.destroyed) return
        this._loadOneTile()
    }

    /** Load all scheduled tiles **/
    loadAll() {
        if (this.destroyed) return
        this._loadAllTiles()
    }

    /** Destroys the loader completly **/
    destroy() {
        this.destroyed = true
        super.destroy()
        try {
            this.loader.reset()
        } catch (error) {
            console.warn('Error while resetting loader', error)
        }
    }

    _onError(loader, error) {
        console.warn('Cannot load', error)
    }

    /** Private method. Called by the PIXI loader after each successfull
     * loading of a single tile.
     * Creates the sprite for the loaded texture and informs the tile layer.
     * @param {Object} loader - the loader instance
     * @param {Object} resource - the loaded resource with url and texture attr
     **/
    _onLoaded(loader, resource) {
        if (this.destroyed) {
            let texture = resource.texture
            let url = resource.url
            Tile.lateTexture(url, texture)
            console.warn('Received resource after destroy', texture)
            return
        }
        try {
            let [col, row] = this.map.get(resource.url)
            this._textureAvailable(resource.url, col, row, resource.texture)
        } catch (err) {
            console.warn('Texture unavailable: ' + err.message)
        }
    }

    /** Private method: loads one tile from the queue. **/
    _loadOneTile(retry = 1) {
        //console.log("_loadOneTile")
        if (this.destroyed) {
            //console.warn("_loadOneTile after destroy")
            return
        }
        if (this.loader.loading) {
            setTimeout(() => {
                this._loadOneTile()
            }, retry)
            return
        }
        if (this.loadQueue.length > 0) {
            let url = this.loadQueue.pop()
            this.loader.add(url, url)
            this.loader.load()
        }
    }

    /** Private method: loads all tiles from the queue in batches. Batches are
    helpfull to avoid loading tiles that are no longer needed because the
    user has already zoomed to a different level.**/
    _loadAllTiles(batchSize = 8, retry = 16) {
        if (this.destroyed) {
            return
        }
        if (this.loadQueue.length > 0) {
            if (this.loader.loading) {
                //console.log("Loader busy", this.loadQueue.length)
                setTimeout(() => {
                    this._loadAllTiles()
                }, retry)
                return
            }
            let i = 0
            let urls = []
            while (i < batchSize && this.loadQueue.length > 0) {
                let url = this.loadQueue.pop()
                if (!this.loaded.has(url)) {
                    let resource = this.loader.resources[url]
                    if (resource) {
                        console.log('Resource already added', url)
                    } else {
                        urls.push(url)
                        i += 1
                    }
                }
            }
            this.loader.add(urls).load(() => {
                this._loadAllTiles()
            })
        }
    }
}

/**
 * Uses XMLHttpRequests but can be replaced with other loaders implementing
 * the public methods without underscore.
 * Calls the Tiles.tileAvailable method if the texture is available.
 **/
export class RequestTileLoader extends TileLoader {
    constructor(tiles, compression) {
        super(tiles)
        this.compression = compression
    }

    schedule(url, col, row) {
        this._load(url, col, row)
        return super.schedule(url, col, row)
    }

    _load(url, col, row, callback = null) {
        if (this.compression) {
            let xhr = new XMLHttpRequest()
            xhr.open('GET', url, false)
            xhr.responseType = 'arraybuffer'
            xhr.onload = e => {
                let CompressedImage = PIXI.compressedTextures.CompressedImage
                let compressed = CompressedImage.loadFromArrayBuffer(xhr.response, url)
                let base = new PIXI.BaseTexture(compressed)
                let texture = new PIXI.Texture(base)
                this._textureAvailable(url, col, row, texture)
                if (callback) callback()
            }
            xhr.send()
        } else {
            let texture = PIXI.Texture.from('assets/image.png')
            this._textureAvailable(url, col, row, texture)
            if (callback) callback()
        }
    }

    /** Load one and only one of the scheduled tiles **/
    loadOneTile() {
        this._loadOneTile()
    }

    /** Load all scheduled tiles **/
    loadAll() {
        this._loadAllTiles()
    }

    /** Private method: loads one tile from the queue. **/
    _loadOneTile(retry = 1) {
        if (this.loadQueue.length > 0) {
            let url = this.loadQueue.pop()
            let [col, row] = this.map.get(url)
            this._load(url, col, row)
        }
    }

    /** Private method: loads all tiles from the queue in batches. Batches are
    helpfull to avoid loading tiles that are no longer needed because the
    user has already zoomed to a different level.**/
    _loadAllTiles(batchSize = 8, retry = 16) {
        if (this.loadQueue.length > 0) {
            let i = 0
            let urls = []
            while (i < batchSize && this.loadQueue.length > 0) {
                let url = this.loadQueue.pop()
                if (this.debug) console.time(url)
                if (!this.loaded.has(url)) {
                    urls.push(url)
                    i += 1
                }
            }
            let total = urls.length
            let count = 0
            for (let url of urls) {
                let [col, row] = this.map.get(url)
                this._load(url, col, row, () => {
                    count++
                    if (count == total) this._loadAllTiles()
                })
            }
        }
    }
}

/**
 * Uses Workers but can be replaced with other loaders implementing
 * the public methods without underscore.
 * Calls the Tiles.tileAvailable method if the texture is available.
 **/
export class WorkerTileLoader extends TileLoader {
    constructor(tiles, workerPath) {
        super(tiles)

        let worker = (this.worker = new Worker(workerPath))

        worker.onmessage = event => {
            if (event.data.success) {
                let { url, col, row, buffer } = event.data
                //console.log("WorkerTileLoader.loaded", url, buffer)
                //let CompressedImage = PIXI.compressedTextures.CompressedImage
                let compressed = PIXI.compressedTextures.loadFromArrayBuffer(buffer, url)
                let base = new PIXI.BaseTexture(compressed)
                let texture = new PIXI.Texture(base)
                this._textureAvailable(url, col, row, texture)
            }
        }
    }

    loadOne() {
        if (this.loadQueue.length > 0) {
            let url = this.loadQueue.pop()
            let [col, row] = this.map.get(url)
            let tile = [col, row, url]
            this.worker.postMessage({ command: 'load', tiles: [tile] })
        }
    }

    loadAll() {
        let tiles = []
        while (this.loadQueue.length > 0) {
            let url = this.loadQueue.pop()
            let [col, row] = this.map.get(url)
            tiles.push([col, row, url])
        }
        this.worker.postMessage({ command: 'load', tiles })
    }

    cancel() {
        super.cancel()
        this.worker.postMessage({ command: 'abort' })
    }

    destroy() {
        this.worker.postMessage({ command: 'abort' })
        this.worker.terminate()
        this.worker = null
        super.destroy()
    }
}