// Copyright 2013 - UDS/CNRS
// The Aladin Lite program is distributed under the terms
// of the GNU General Public License version 3.
//
// This file is part of Aladin Lite.
//
//    Aladin Lite is free software: you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation, version 3 of the License.
//
//    Aladin Lite is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    The GNU General Public License is available in COPYING file
//    along with Aladin Lite.
//

/******************************************************************************
 * Aladin Lite project
 *
 * File HiPS
 *
 * Authors: Thomas Boch & Matthieu Baumann [CDS]
 *
 *****************************************************************************/
import { ALEvent } from "./events/ALEvent.js";
import { ColorCfg } from "./ColorCfg.js";
import { HiPSProperties } from "./HiPSProperties.js";

let PropertyParser = {};
// Utilitary functions for parsing the properties and giving default values
/// Mandatory tileSize property
PropertyParser.tileSize = function (properties) {
    let tileSize =
        (properties &&
            properties.hips_tile_width &&
            +properties.hips_tile_width) ||
        512;

    // Check if the tile width size is a power of 2
    if (tileSize & (tileSize - 1 !== 0)) {
        tileSize = 512;
    }

    return tileSize;
};

/// Mandatory frame property
PropertyParser.cooFrame = function (properties) {
    let cooFrame =
        (properties && properties.hips_body && "ICRSd") ||
        (properties && properties.hips_frame) ||
        "ICRS";
    return cooFrame;
};

/// Mandatory maxOrder property
PropertyParser.maxOrder = function (properties) {
    let maxOrder =
        properties && properties.hips_order && +properties.hips_order;
    return maxOrder;
};

/// Mandatory minOrder property
PropertyParser.minOrder = function (properties) {
    const minOrder =
        (properties &&
            properties.hips_order_min &&
            +properties.hips_order_min) ||
        0;
    return minOrder;
};

PropertyParser.formats = function (properties) {
    let formats = (properties && properties.hips_tile_format) || "jpeg";

    formats = formats.split(" ").map((fmt) => fmt.toLowerCase());

    return formats;
};

PropertyParser.initialFov = function (properties) {
    let initialFov =
        properties &&
        properties.hips_initial_fov &&
        +properties.hips_initial_fov;

    if (initialFov && initialFov < 0.00002777777) {
        initialFov = 360;
    }

    return initialFov;
};

PropertyParser.skyFraction = function (properties) {
    const skyFraction =
        (properties &&
            properties.moc_sky_fraction &&
            +properties.moc_sky_fraction) ||
        0.0;
    return skyFraction;
};

PropertyParser.cutouts = function (properties) {
    let cuts =
        properties &&
        properties.hips_pixel_cut &&
        properties.hips_pixel_cut.split(" ");

    const minCutout = cuts && parseFloat(cuts[0]);
    const maxCutout = cuts && parseFloat(cuts[1]);

    return [minCutout, maxCutout];
};

PropertyParser.bitpix = function (properties) {
    const bitpix =
        properties &&
        properties.hips_pixel_bitpix &&
        +properties.hips_pixel_bitpix;
    return bitpix;
};

PropertyParser.isPlanetaryBody = function (properties) {
    return properties && properties.hips_body !== undefined;
};

/**
 * @typedef {Object} HiPSOptions
 *
 * @property {string} [name] - The name of the survey to be displayed in the UI
 * @property {Function} [successCallback] - A callback executed when the HiPS has been loaded
 * @property {Function} [errorCallback] - A callback executed when the HiPS could not be loaded
 * @property {string} [imgFormat] - Formats accepted 'webp', 'png', 'jpeg' or 'fits'. Will raise an error if the HiPS does not contain tiles in this format
 * @property {CooFrame} [cooFrame="J2000"] - Coordinate frame of the survey tiles
 * @property {number} [maxOrder] - The maximum HEALPix order of the HiPS, i.e the HEALPix order of the most refined tile images of the HiPS.
 * @property {number} [numBitsPerPixel] - Useful if you want to display the FITS tiles of a HiPS. It specifies the number of bits per pixel. Possible values are:
 * -64: double, -32: float, 8: unsigned byte, 16: short, 32: integer 32 bits, 64: integer 64 bits
 * @property {number} [tileSize] - The width of the HEALPix tile images. Mostly 512 pixels but can be 256, 128, 64, 32
 * @property {number} [minOrder] - If not given, retrieved from the properties of the survey.
 * @property {boolean} [longitudeReversed=false] - Set it to True for planetary survey visualization 
 * @property {number} [opacity=1.0] - Opacity of the survey or image (value between 0 and 1).
 * @property {string} [colormap="native"] - The colormap configuration for the survey or image.
 * @property {string} [stretch="linear"] - The stretch configuration for the survey or image.
 * @property {boolean} [reversed=false] - If true, the colormap is reversed; otherwise, it is not reversed.
 * @property {number} [minCut] - The minimum cut value for the color configuration. If not given, 0.0 for JPEG/PNG surveys, the value of the property file for FITS surveys
 * @property {number} [maxCut] - The maximum cut value for the color configuration. If not given, 1.0 for JPEG/PNG surveys, the value of the property file for FITS surveys
 * @property {boolean} [additive=false] - If true, additive blending is applied; otherwise, it is not applied.
 * @property {number} [gamma=1.0] - The gamma correction value for the color configuration.
 * @property {number} [saturation=0.0] - The saturation value for the color configuration.
 * @property {number} [brightness=0.0] - The brightness value for the color configuration.
 * @property {number} [contrast=0.0] - The contrast value for the color configuration.
 */
export let HiPS = (function () {
    /**
     * The object describing an image survey
     *
     * @class
     * @constructs HiPS
     *
     * @param {string} id - Mandatory unique identifier for the layer. Can be an arbitrary name
     * @param {string} location - Can be:
     * - an http url <br/> 
     * - a relative path to your HiPS <br/>
     * - a special ID pointing towards a HiPS. One can found the list of IDs {@link https://aladin.cds.unistra.fr/hips/list| here}
     * @param {HiPSOptions} [options] - The option for the survey
     *
     * @description Giving a CDS ID will do a query to the MOCServer first to retrieve metadata. Then it will also check for the presence of faster HiPS nodes to choose a faster url to query to tiles from.
     */
    function HiPS(id, location, options) {
        this.added = false;
        // Unique identifier for a survey
        this.id = id;

        this.options = options;
        this.name = (options && options.name) || undefined;
        this.startUrl = options.startUrl;

        this.url = location;
        this.maxOrder = options.maxOrder;
        this.minOrder = options.minOrder || 0;
        this.cooFrame = options.cooFrame;
        this.tileSize = options.tileSize;
        this.skyFraction = options.skyFraction;
        this.longitudeReversed =
            options.longitudeReversed === undefined
                ? false
                : options.longitudeReversed;
        this.imgFormat = options.imgFormat;
        this.formats = options.formats;
        this.defaultFitsMinCut = options.defaultFitsMinCut;
        this.defaultFitsMaxCut = options.defaultFitsMaxCut;
        this.numBitsPerPixel = options.numBitsPerPixel;
        this.creatorDid = options.creatorDid;
        this.errorCallback = options.errorCallback;
        this.successCallback = options.successCallback;

        this.colorCfg = new ColorCfg(options);
    };

    HiPS.prototype._fetchFasterUrlFromProperties = function(properties) {
        let self = this;

        HiPSProperties.getFasterMirrorUrl(properties)
            .then((url) => {
                if (self.url !== url) {
                    console.info(
                        "Change url of ",
                        self.id,
                        " to ",
                        url
                    );

                    self.url = url;

                    // If added to the backend, then we need to tell it the url has changed
                    if (self.added) {
                        self.view.wasm.setHiPSUrl(
                            self.creatorDid,
                            url
                        );
                    }
                }
            })
            .catch((e) => {
                console.error(self);
                console.error(e);
            });
    }

    HiPS.prototype._parseProperties = function(properties) {
        let self = this;
        self.creatorDid = properties.creator_did || self.creatorDid;
        // url

        // Max order
        self.maxOrder =
            PropertyParser.maxOrder(properties) || self.maxOrder;

        // Tile size
        self.tileSize =
            PropertyParser.tileSize(properties) || self.tileSize;

        // Tile formats
        self.formats =
            PropertyParser.formats(properties) || self.formats;

        // min order
        self.minOrder =
            PropertyParser.minOrder(properties) || self.minOrder;

        // Frame
        self.cooFrame =
            PropertyParser.cooFrame(properties) || self.cooFrame;

        // sky fraction
        self.skyFraction = PropertyParser.skyFraction(properties);

        // Initial fov/ra/dec
        self.initialFov = PropertyParser.initialFov(properties);
        self.initialRa =
            properties &&
            properties.hips_initial_ra &&
            +properties.hips_initial_ra;
        self.initialDec =
            properties &&
            properties.hips_initial_dec &&
            +properties.hips_initial_dec;

        // Cutouts
        const cutoutFromProperties = PropertyParser.cutouts(properties);
        self.defaultFitsMinCut = cutoutFromProperties[0];
        self.defaultFitsMaxCut = cutoutFromProperties[1];

        // Bitpix
        self.numBitsPerPixel =
            PropertyParser.bitpix(properties) || self.numBitsPerPixel;

        // HiPS body
        if (properties.hips_body) {
            self.hipsBody = properties.hips_body;
            // Use the property to define and check some user given infos
            // Longitude reversed
            self.longitudeReversed = true;
        }

        // Give a better name if we have the HiPS metadata
        self.name = self.name || properties.obs_title;

        self.name = self.name || self.id || self.url;
        self.name = self.name.replace(/  +/g, ' ');

        self.creatorDid = self.creatorDid || self.id || self.url;

        // Image format
        if (self.imgFormat) {
            // transform to lower case
            self.imgFormat = self.imgFormat.toLowerCase();
            // convert JPG -> JPEG
            if (self.imgFormat === "jpg") {
                self.imgFormat = "jpeg";
            }

            // user wants a fits but the properties tells this format is not available
            if (
                self.imgFormat === "fits" &&
                self.formats &&
                self.formats.indexOf("fits") < 0
            ) {
                throw self.name + " does not provide fits tiles";
            }

            if (
                self.imgFormat === "webp" &&
                self.formats &&
                self.formats.indexOf("webp") < 0
            ) {
                throw self.name + " does not provide webp tiles";
            }

            if (
                self.imgFormat === "png" &&
                self.formats &&
                self.formats.indexOf("png") < 0
            ) {
                throw self.name + " does not provide png tiles";
            }

            if (
                self.imgFormat === "jpeg" &&
                self.formats &&
                self.formats.indexOf("jpeg") < 0
            ) {
                throw self.name + " does not provide jpeg tiles";
            }
        } else {
            // user wants nothing then we choose one from the properties
            if (self.formats.indexOf("webp") >= 0) {
                self.imgFormat = "webp";
            } else if (self.formats.indexOf("png") >= 0) {
                self.imgFormat = "png";
            } else if (self.formats.indexOf("jpeg") >= 0) {
                self.imgFormat = "jpeg";
            } else if (self.formats.indexOf("fits") >= 0) {
                self.imgFormat = "fits";
            } else {
                throw (
                    "Unsupported format(s) found in the properties: " +
                    self.formats
                );
            }
        }

        // Cutouts
        let minCut, maxCut;
        if (self.imgFormat === "fits") {
            // Take into account the default cuts given by the property file (this is true especially for FITS HiPSes)
            minCut = self.colorCfg.minCut || self.defaultFitsMinCut || 0.0;
            maxCut = self.colorCfg.maxCut || self.defaultFitsMaxCut || 1.0;
        } else {
            minCut = self.colorCfg.minCut || 0.0;
            maxCut = self.colorCfg.maxCut || 1.0;
        }

        self.setOptions({minCut, maxCut});

        // Coo frame
        if (
            self.cooFrame == "ICRS" ||
            self.cooFrame == "ICRSd" ||
            self.cooFrame == "equatorial" ||
            self.cooFrame == "j2000"
        ) {
            self.cooFrame = "ICRS";
        } else if (self.cooFrame == "galactic" || self.cooFrame == "GAL") {
            self.cooFrame = "GAL";
        } else {
            console.warn(
                "Invalid cooframe given: " +
                    self.cooFrame +
                    '. Coordinate systems supported: "ICRS", "ICRSd", "j2000" or "galactic". ICRS is chosen by default'
            );
            self.cooFrame = "ICRS";

        }

        self.formats = self.formats || [self.imgFormat];

        self._saveInCache();
    }

    HiPS.prototype.setView = function (view) {
        let self = this;

        // do not allow to call setView multiple times otherwise
        // the querying to the properties and the search to the best
        // HiPS node will be done again for the same hiPS
        if (this.view) {
            return;
        }
        this.view = view;

        let isIncompleteOptions = true;
        // This is very dirty but it allows me to differentiate the location from 
        // whether an ID or a plain url
        let isID = this.url.includes("P/") || this.url.includes("C/")

        if (this.imgFormat === "fits") {
            // a fits is given
            isIncompleteOptions = !(
                this.maxOrder &&
                (!isID && this.url) &&
                this.imgFormat &&
                this.tileSize &&
                this.cooFrame &&
                this.numBitsPerPixel
            );
        } else {
            isIncompleteOptions = !(
                this.maxOrder &&
                (!isID && this.url) &&
                this.imgFormat &&
                this.tileSize &&
                this.cooFrame
            );
        }

        self.query = (async () => {

            if (isIncompleteOptions) {
                // ID typed url
                if (self.startUrl && isID) {
                    // First download the properties from the start url
                    await HiPSProperties.fetchFromUrl(self.startUrl)
                        .then((p) => {
                            self._parseProperties(p);
                        })

                    try {
                        // the url stores a "CDS ID" we take it prioritaly
                        // if the url is null, take the id, this is for some tests
                        // to pass because some users might just give null as url param and a "CDS ID" as id param
                        let id = self.url || self.id;

                        self.url = self.startUrl;

                        setTimeout(
                            () => {
                                if (!self.added)
                                    return;

                                HiPSProperties.fetchFromID(id)
                                    .then((p) => {
                                        //self.url = self.startUrl;
                                        self._fetchFasterUrlFromProperties(p);
                                    })
                            },
                            1000
                        );
                        

                    } catch (e) {
                        throw e;
                    }
                } else if (!this.startUrl && isID) {
                    try {
                        // the url stores a "CDS ID" we take it prioritaly
                        // if the url is null, take the id, this is for some tests
                        // to pass because some users might just give null as url param and a "CDS ID" as id param
                        let id = self.url || self.id;

                        await HiPSProperties.fetchFromID(id)
                            .then((p) => {
                                self.url = p.hips_service_url;

                                self._parseProperties(p);
                                self._fetchFasterUrlFromProperties(p);
                            })
                    } catch (e) {
                        throw e;
                    }
                } else {
                    await HiPSProperties.fetchFromUrl(self.url)
                        .then((p) => {
                            self._parseProperties(p);
                        })
                }
            } else {
                self._parseProperties({
                    hips_order: this.maxOrder,
                    hips_service_url: this.url,
                    hips_tile_width: this.tileSize,
                    hips_frame: this.cooFrame
                })
            }

            return self;
        })()
    };

    /* Precondition: view is attached */
    HiPS.prototype._saveInCache = function () {
        let self = this;
        let hipsCache = this.view.aladin.hipsCache;

        if (hipsCache.contains(self.id)) {
            hipsCache.append(self.id, this)
        }
    };

    /**
     * Checks if the HiPS represents a planetary body.
     *
     * This method returns a boolean indicating whether the HiPS corresponds to a planetary body, e.g. the earth or a celestial body.
     *
     * @memberof HiPS
     *
     * @returns {boolean} Returns true if the HiPS represents a planetary body; otherwise, returns false.
     */
    HiPS.prototype.isPlanetaryBody = function () {
        return this.hipsBody !== undefined;
    };

    /**
     * Sets the image format for the HiPS.
     *
     * This method updates the image format of the HiPS, performs format validation, and triggers the update of metadata.
     *
     * @memberof HiPS
     *
     * @param {string} format - The desired image format. Should be one of ["fits", "png", "jpg", "webp"].
     *
     * @throws {string} Throws an error if the provided format is not one of the supported formats or if the format is not available for the specific HiPS.
     */
    HiPS.prototype.setImageFormat = function (format) {
        let self = this;
        self.query.then(() => {
            let imgFormat = format.toLowerCase();

            if (
                imgFormat !== "fits" &&
                imgFormat !== "png" &&
                imgFormat !== "jpg" &&
                imgFormat !== "jpeg" &&
                imgFormat !== "webp"
            ) {
                throw 'Formats must lie in ["fits", "png", "jpg", "webp"]';
            }

            if (imgFormat === "jpg") {
                imgFormat = "jpeg";
            }

            // Passed the check, we erase the image format with the new one
            // We do nothing if the imgFormat is the same
            if (self.imgFormat === imgFormat) {
                return;
            }

            // Check the properties to see if the given format is available among the list
            // If the properties have not been retrieved yet, it will be tested afterwards
            const availableFormats = self.formats;
            // user wants a fits but the metadata tells this format is not available
            if (
                imgFormat === "fits" &&
                availableFormats.indexOf("fits") < 0
            ) {
                throw self.id + " does not provide fits tiles";
            }

            if (
                imgFormat === "webp" &&
                availableFormats.indexOf("webp") < 0
            ) {
                throw self.id + " does not provide webp tiles";
            }

            if (
                imgFormat === "png" &&
                availableFormats.indexOf("png") < 0
            ) {
                throw self.id + " does not provide png tiles";
            }

            if (
                imgFormat === "jpeg" &&
                availableFormats.indexOf("jpeg") < 0
            ) {
                throw self.id + " does not provide jpeg tiles";
            }

            // Switch from png/webp/jpeg to fits
            if (
                (self.imgFormat === "png" ||
                    self.imgFormat === "webp" ||
                    self.imgFormat === "jpeg") &&
                imgFormat === "fits"
            ) {
                if (Number.isFinite(self.defaultFitsMinCut) && Number.isFinite(self.defaultFitsMaxCut)) {
                    // reset cuts to those given from the properties
                    self.setCuts(self.defaultFitsMinCut, self.defaultFitsMaxCut);
                }
                // Switch from fits to png/webp/jpeg
            } else if (self.imgFormat === "fits") {
                self.setCuts(0.0, 1.0);
            }

            // Check if it is a fits
            self.imgFormat = imgFormat;

            self._updateMetadata();
        });
    };

    /**
     * Sets the opacity factor when rendering the HiPS
     *
     * @memberof HiPS
     *
     * @returns {string[]} Returns the formats accepted for the survey, i.e. the formats of tiles that are availables. Could be PNG, WEBP, JPG and FITS.
     */
    HiPS.prototype.getAvailableFormats = function () {
        return this.formats;
    };

    /**
     * Sets the opacity factor when rendering the HiPS
     *
     * @memberof HiPS
     *
     * @param {number} opacity - Opacity of the survey to set. Between 0 and 1
     */
    HiPS.prototype.setOpacity = function (opacity) {
        this.setOptions({opacity})
    };

    /**
     * Sets the blending mode when rendering the HiPS
     *
     * @memberof HiPS
     *
     * @param {boolean} [additive=false] -
     *
     * @description Two rendering modes are availables i.e. the default one and the additive one.
     * When rendering this survey on top of the already rendered ones, the final color of the screen is computed like:
     * <br>
     * <br>opacity * this_survey_color + (1 - opacity) * already_rendered_color for the default mode
     * <br>opacity * this_survey_color + already_rendered_color for the additive mode
     * <br>
     * <br>
     * Additive mode allows you to do linear survey color combination i.e. let's define 3 surveys named s1, s2, s3. Each could be associated to one color channel, i.e. s1 with red, s2 with green and s3 with the blue color channel.
     * If the additive blending mode is enabled, then the final pixel color of your screen will be: rgb = [s1_opacity * s1_color; s2_opacity * s2_color; s3_opacity * s3_color]
     */
    HiPS.prototype.setBlendingConfig = function (additive = false) {
        this.setOptions({additive});
    };

    /**
     * Sets the colormap when rendering the HiPS.
     *
     * @memberof HiPS
     *
     * @param {string} [colormap="grayscale"] - The colormap label to use. See {@link https://matplotlib.org/stable/users/explain/colors/colormaps.html|here} for more info about colormaps.
     *      Possible values are:
     * <br>"blues"
     * <br>"cividis"
     * <br>"cubehelix"
     * <br>"eosb"
     * <br>"grayscale"
     * <br>"inferno"
     * <br>"magma"
     * <br>"native"
     * <br>"parula"
     * <br>"plasma"
     * <br>"rainbow"
     * <br>"rdbu"
     * <br>"rdylbu"
     * <br>"redtemperature"
     * <br>"sinebow"
     * <br>"spectral"
     * <br>"summer"
     * <br>"viridis"
     * <br>"ylgnbu"
     * <br>"ylorbr"
     * <br>"red"
     * <br>"green"
     * <br>"blue"
     * @param {Object} [options] - Options for the colormap
     * @param {string} [options.stretch] - Stretching function of the colormap. Possible values are 'linear', 'asinh', 'log', 'sqrt', 'pow'. If no given, will not change it.
     * @param {boolean} [options.reversed=false] - Reverse the colormap axis.
     */
    HiPS.prototype.setColormap = function (colormap, options) {
        this.setOptions({colormap, ...options})
    };

    /**
     * Sets the gamma correction factor for the HiPS.
     *
     * This method updates the gamma of the HiPS.
     *
     * @memberof HiPS
     *
     * @param {number} minCut - The low cut value to set for the HiPS.
     * @param {number} maxCut - The high cut value to set for the HiPS.
     */
    HiPS.prototype.setCuts = function (minCut, maxCut) {
        this.setOptions({minCut, maxCut})
    };

    HiPS.prototype.getCuts = function () {
        return this.colorCfg.getCuts();
    };

    /**
     * Sets the gamma correction factor for the HiPS.
     *
     * This method updates the gamma of the HiPS.
     *
     * @memberof HiPS
     *
     * @param {number} gamma - The saturation value to set for the HiPS. Between 0.1 and 10
     */
    HiPS.prototype.setGamma = function (gamma) {
        this.setOptions({gamma})
    };

    /**
     * Sets the saturation for the HiPS.
     *
     * This method updates the saturation of the HiPS.
     *
     * @memberof HiPS
     *
     * @param {number} saturation - The saturation value to set for the HiPS. Between 0 and 1
     */
    HiPS.prototype.setSaturation = function (saturation) {
        this.setOptions({saturation})
    };

    /**
     * Sets the brightness for the HiPS.
     *
     * This method updates the brightness of the HiPS.
     *
     * @memberof HiPS
     *
     * @param {number} brightness - The brightness value to set for the HiPS. Between 0 and 1
     */
    HiPS.prototype.setBrightness = function (brightness) {
        this.setOptions({brightness})
    };

    /**
     * Sets the contrast for the HiPS.
     *
     * This method updates the contrast of the HiPS and triggers the update of metadata.
     *
     * @memberof HiPS
     *
     * @param {number} contrast - The contrast value to set for the HiPS. Between 0 and 1
     */
    HiPS.prototype.setContrast = function (contrast) {
        this.setOptions({contrast})
    };

    // Private method for updating the backend with the new meta
    HiPS.prototype._updateMetadata = function () {
        try {
            if (this.added) {
                this.view.wasm.setImageMetadata(this.layer, {
                    ...this.colorCfg.get(),
                    longitudeReversed: this.longitudeReversed,
                    imgFormat: this.imgFormat,
                });
                // once the meta have been well parsed, we can set the meta
                ALEvent.HIPS_LAYER_CHANGED.dispatchedTo(this.view.aladinDiv, {
                    layer: this,
                });

                // Save it in the JS HiPS cache
                this._saveInCache();
            }
        } catch (e) {
            // Display the error message
            console.error(e);
        }
    };

    HiPS.prototype.setOptions = function(options) {
        this.colorCfg.setOptions(options);
        this.options = {...this.options, ...options};

        this._updateMetadata();
    };

    HiPS.prototype.add = function (layer) {
        this.layer = layer;
        let self = this;

        this.view.wasm.addHiPS({
            layer,
            properties: {
                creatorDid: self.creatorDid,
                url: self.url,
                maxOrder: self.maxOrder,
                cooFrame: self.cooFrame,
                tileSize: self.tileSize,
                formats: self.formats,
                bitpix: self.numBitsPerPixel,
                skyFraction: self.skyFraction,
                minOrder: self.minOrder,
                hipsInitialFov: self.initialFov,
                hipsInitialRa: self.initialRa,
                hipsInitialDec: self.initialDec,
                isPlanetaryBody: self.isPlanetaryBody(),
                hipsBody: self.hipsBody,
            },
            meta: {
                ...this.colorCfg.get(),
                longitudeReversed: this.longitudeReversed,
                imgFormat: this.imgFormat,
            },
        });

        return Promise.resolve(this)
            .then((hips) => {
                if (hips.successCallback) {
                    hips.successCallback(hips)
                }

                return hips
            });
    };

    // @api
    HiPS.prototype.toggle = function () {
        const opacity = this.getOpacity()
        if (opacity != 0.0) {
            this.prevOpacity = opacity;
            this.setOpacity(0.0);
        } else {
            this.setOpacity(this.prevOpacity);
        }
    };

    // @oldapi
    HiPS.prototype.setAlpha = HiPS.prototype.setOpacity;

    HiPS.prototype.setColorCfg = function (colorCfg) {
        this.colorCfg = colorCfg;

        this._updateMetadata();
    };

    // @api
    HiPS.prototype.getColorCfg = function () {
        return this.colorCfg;
    };

    // @api
    HiPS.prototype.getOpacity = function () {
        return this.colorCfg.getOpacity();
    };

    HiPS.prototype.getAlpha = HiPS.prototype.getOpacity;

    // @api
    HiPS.prototype.readPixel = function (x, y) {
        return this.view.wasm.readPixel(x, y, this.layer);
    };

    HiPS.DEFAULT_SURVEY_ID = "P/DSS2/color";

    return HiPS;
})();
