import defined from '../Core/defined.js';
import defineProperties from '../Core/defineProperties.js';
import DeveloperError from '../Core/DeveloperError.js';
import Rectangle from '../Core/Rectangle.js';
import QuadtreeTileLoadState from './QuadtreeTileLoadState.js';
import TileSelectionResult from './TileSelectionResult.js';

    /**
     * A single tile in a {@link QuadtreePrimitive}.
     *
     * @alias QuadtreeTile
     * @constructor
     * @private
     *
     * @param {Number} options.level The level of the tile in the quadtree.
     * @param {Number} options.x The X coordinate of the tile in the quadtree.  0 is the westernmost tile.
     * @param {Number} options.y The Y coordinate of the tile in the quadtree.  0 is the northernmost tile.
     * @param {TilingScheme} options.tilingScheme The tiling scheme in which this tile exists.
     * @param {QuadtreeTile} [options.parent] This tile's parent, or undefined if this is a root tile.
     */
    function QuadtreeTile(options) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(options)) {
            throw new DeveloperError('options is required.');
        }
        if (!defined(options.x)) {
            throw new DeveloperError('options.x is required.');
        } else if (!defined(options.y)) {
            throw new DeveloperError('options.y is required.');
        } else if (options.x < 0 || options.y < 0) {
            throw new DeveloperError('options.x and options.y must be greater than or equal to zero.');
        }
        if (!defined(options.level)) {
            throw new DeveloperError('options.level is required and must be greater than or equal to zero.');
        }
        if (!defined(options.tilingScheme)) {
            throw new DeveloperError('options.tilingScheme is required.');
        }
        //>>includeEnd('debug');

        this._tilingScheme = options.tilingScheme;
        this._x = options.x;
        this._y = options.y;
        this._level = options.level;
        this._parent = options.parent;
        this._rectangle = this._tilingScheme.tileXYToRectangle(this._x, this._y, this._level);

        this._southwestChild = undefined;
        this._southeastChild = undefined;
        this._northwestChild = undefined;
        this._northeastChild = undefined;

        // TileReplacementQueue gets/sets these private properties.
        this.replacementPrevious = undefined;
        this.replacementNext = undefined;

        // The distance from the camera to this tile, updated when the tile is selected
        // for rendering.  We can get rid of this if we have a better way to sort by
        // distance - for example, by using the natural ordering of a quadtree.
        // QuadtreePrimitive gets/sets this private property.
        this._distance = 0.0;
        this._loadPriority = 0.0;

        this._customData = [];
        this._frameUpdated = undefined;
        this._lastSelectionResult = TileSelectionResult.NONE;
        this._lastSelectionResultFrame = undefined;
        this._loadedCallbacks = {};

        /**
         * Gets or sets the current state of the tile in the tile load pipeline.
         * @type {QuadtreeTileLoadState}
         * @default {@link QuadtreeTileLoadState.START}
         */
        this.state = QuadtreeTileLoadState.START;

        /**
         * Gets or sets a value indicating whether or not the tile is currently renderable.
         * @type {Boolean}
         * @default false
         */
        this.renderable = false;

        /**
         * Gets or set a value indicating whether or not the tile was entirely upsampled from its
         * parent tile.  If all four children of a parent tile were upsampled from the parent,
         * we will render the parent instead of the children even if the LOD indicates that
         * the children would be preferable.
         * @type {Boolean}
         * @default false
         */
        this.upsampledFromParent = false;

        /**
         * Gets or sets the additional data associated with this tile.  The exact content is specific to the
         * {@link QuadtreeTileProvider}.
         * @type {Object}
         * @default undefined
         */
        this.data = undefined;
    }

    /**
     * Creates a rectangular set of tiles for level of detail zero, the coarsest, least detailed level.
     *
     * @memberof QuadtreeTile
     *
     * @param {TilingScheme} tilingScheme The tiling scheme for which the tiles are to be created.
     * @returns {QuadtreeTile[]} An array containing the tiles at level of detail zero, starting with the
     * tile in the northwest corner and followed by the tile (if any) to its east.
     */
    QuadtreeTile.createLevelZeroTiles = function(tilingScheme) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(tilingScheme)) {
            throw new DeveloperError('tilingScheme is required.');
        }
        //>>includeEnd('debug');

        var numberOfLevelZeroTilesX = tilingScheme.getNumberOfXTilesAtLevel(0);
        var numberOfLevelZeroTilesY = tilingScheme.getNumberOfYTilesAtLevel(0);

        var result = new Array(numberOfLevelZeroTilesX * numberOfLevelZeroTilesY);

        var index = 0;
        for (var y = 0; y < numberOfLevelZeroTilesY; ++y) {
            for (var x = 0; x < numberOfLevelZeroTilesX; ++x) {
                result[index++] = new QuadtreeTile({
                    tilingScheme : tilingScheme,
                    x : x,
                    y : y,
                    level : 0
                });
            }
        }

        return result;
    };

    QuadtreeTile.prototype._updateCustomData = function(frameNumber, added, removed) {
        var customData = this.customData;

        var i;
        var data;
        var rectangle;

        if (defined(added) && defined(removed)) {
            customData = customData.filter(function(value) {
                return removed.indexOf(value) === -1;
            });
            this._customData = customData;

            rectangle = this._rectangle;
            for (i = 0; i < added.length; ++i) {
                data = added[i];
                if (Rectangle.contains(rectangle, data.positionCartographic)) {
                    customData.push(data);
                }
            }

            this._frameUpdated = frameNumber;
        } else {
            // interior or leaf tile, update from parent
            var parent = this._parent;
            if (defined(parent) && this._frameUpdated !== parent._frameUpdated) {
                customData.length = 0;

                rectangle = this._rectangle;
                var parentCustomData = parent.customData;
                for (i = 0; i < parentCustomData.length; ++i) {
                    data = parentCustomData[i];
                    if (Rectangle.contains(rectangle, data.positionCartographic)) {
                        customData.push(data);
                    }
                }

                this._frameUpdated = parent._frameUpdated;
            }
        }
    };

    defineProperties(QuadtreeTile.prototype, {
        /**
         * Gets the tiling scheme used to tile the surface.
         * @memberof QuadtreeTile.prototype
         * @type {TilingScheme}
         */
        tilingScheme : {
            get : function() {
                return this._tilingScheme;
            }
        },

        /**
         * Gets the tile X coordinate.
         * @memberof QuadtreeTile.prototype
         * @type {Number}
         */
        x : {
            get : function() {
                return this._x;
            }
        },

        /**
         * Gets the tile Y coordinate.
         * @memberof QuadtreeTile.prototype
         * @type {Number}
         */
        y : {
            get : function() {
                return this._y;
            }
        },

        /**
         * Gets the level-of-detail, where zero is the coarsest, least-detailed.
         * @memberof QuadtreeTile.prototype
         * @type {Number}
         */
        level : {
            get : function() {
                return this._level;
            }
        },

        /**
         * Gets the parent tile of this tile.
         * @memberof QuadtreeTile.prototype
         * @type {QuadtreeTile}
         */
        parent : {
            get : function() {
                return this._parent;
            }
        },

        /**
         * Gets the cartographic rectangle of the tile, with north, south, east and
         * west properties in radians.
         * @memberof QuadtreeTile.prototype
         * @type {Rectangle}
         */
        rectangle : {
            get : function() {
                return this._rectangle;
            }
        },

        /**
         * An array of tiles that is at the next level of the tile tree.
         * @memberof QuadtreeTile.prototype
         * @type {QuadtreeTile[]}
         */
        children : {
            get : function() {
                return [this.northwestChild, this.northeastChild, this.southwestChild, this.southeastChild];
            }
        },

        /**
         * Gets the southwest child tile.
         * @memberof QuadtreeTile.prototype
         * @type {QuadtreeTile}
         */
        southwestChild : {
            get : function() {
                if (!defined(this._southwestChild)) {
                    this._southwestChild = new QuadtreeTile({
                        tilingScheme : this.tilingScheme,
                        x : this.x * 2,
                        y : this.y * 2 + 1,
                        level : this.level + 1,
                        parent : this
                    });
                }
                return this._southwestChild;
            }
        },

        /**
         * Gets the southeast child tile.
         * @memberof QuadtreeTile.prototype
         * @type {QuadtreeTile}
         */
        southeastChild : {
            get : function() {
                if (!defined(this._southeastChild)) {
                    this._southeastChild = new QuadtreeTile({
                        tilingScheme : this.tilingScheme,
                        x : this.x * 2 + 1,
                        y : this.y * 2 + 1,
                        level : this.level + 1,
                        parent : this
                    });
                }
                return this._southeastChild;
            }
        },

        /**
         * Gets the northwest child tile.
         * @memberof QuadtreeTile.prototype
         * @type {QuadtreeTile}
         */
        northwestChild : {
            get : function() {
                if (!defined(this._northwestChild)) {
                    this._northwestChild = new QuadtreeTile({
                        tilingScheme : this.tilingScheme,
                        x : this.x * 2,
                        y : this.y * 2,
                        level : this.level + 1,
                        parent : this
                    });
                }
                return this._northwestChild;
            }
        },

        /**
         * Gets the northeast child tile.
         * @memberof QuadtreeTile.prototype
         * @type {QuadtreeTile}
         */
        northeastChild : {
            get : function() {
                if (!defined(this._northeastChild)) {
                    this._northeastChild = new QuadtreeTile({
                        tilingScheme : this.tilingScheme,
                        x : this.x * 2 + 1,
                        y : this.y * 2,
                        level : this.level + 1,
                        parent : this
                    });
                }
                return this._northeastChild;
            }
        },

        /**
         * An array of objects associated with this tile.
         * @memberof QuadtreeTile.prototype
         * @type {Array}
         */
        customData : {
            get : function() {
                return this._customData;
            }
        },

        /**
         * Gets a value indicating whether or not this tile needs further loading.
         * This property will return true if the {@link QuadtreeTile#state} is
         * <code>START</code> or <code>LOADING</code>.
         * @memberof QuadtreeTile.prototype
         * @type {Boolean}
         */
        needsLoading : {
            get : function() {
                return this.state < QuadtreeTileLoadState.DONE;
            }
        },

        /**
         * Gets a value indicating whether or not this tile is eligible to be unloaded.
         * Typically, a tile is ineligible to be unloaded while an asynchronous operation,
         * such as a request for data, is in progress on it.  A tile will never be
         * unloaded while it is needed for rendering, regardless of the value of this
         * property.  If {@link QuadtreeTile#data} is defined and has an
         * <code>eligibleForUnloading</code> property, the value of that property is returned.
         * Otherwise, this property returns true.
         * @memberof QuadtreeTile.prototype
         * @type {Boolean}
         */
        eligibleForUnloading : {
            get : function() {
                var result = true;

                if (defined(this.data)) {
                    result = this.data.eligibleForUnloading;
                    if (!defined(result)) {
                        result = true;
                    }
                }

                return result;
            }
        }
    });

    QuadtreeTile.prototype.findLevelZeroTile = function(levelZeroTiles, x, y) {
        var xTiles = this.tilingScheme.getNumberOfXTilesAtLevel(0);
        if (x < 0) {
            x += xTiles;
        } else if (x >= xTiles) {
            x -= xTiles;
        }

        if (y < 0 || y >= this.tilingScheme.getNumberOfYTilesAtLevel(0)) {
            return undefined;
        }

        return levelZeroTiles.filter(function(tile) {
            return tile.x === x && tile.y === y;
        })[0];
    };

    QuadtreeTile.prototype.findTileToWest = function(levelZeroTiles) {
        var parent = this.parent;
        if (parent === undefined) {
            return this.findLevelZeroTile(levelZeroTiles, this.x - 1, this.y);
        }

        if (parent.southeastChild === this) {
            return parent.southwestChild;
        } else if (parent.northeastChild === this) {
            return parent.northwestChild;
        }

        var westOfParent = parent.findTileToWest(levelZeroTiles);
        if (westOfParent === undefined) {
            return undefined;
        } else if (parent.southwestChild === this) {
            return westOfParent.southeastChild;
        }
        return westOfParent.northeastChild;
    };

    QuadtreeTile.prototype.findTileToEast = function(levelZeroTiles) {
        var parent = this.parent;
        if (parent === undefined) {
            return this.findLevelZeroTile(levelZeroTiles, this.x + 1, this.y);
        }

        if (parent.southwestChild === this) {
            return parent.southeastChild;
        } else if (parent.northwestChild === this) {
            return parent.northeastChild;
        }

        var eastOfParent = parent.findTileToEast(levelZeroTiles);
        if (eastOfParent === undefined) {
            return undefined;
        } else if (parent.southeastChild === this) {
            return eastOfParent.southwestChild;
        }
        return eastOfParent.northwestChild;
    };

    QuadtreeTile.prototype.findTileToSouth = function(levelZeroTiles) {
        var parent = this.parent;
        if (parent === undefined) {
            return this.findLevelZeroTile(levelZeroTiles, this.x, this.y + 1);
        }

        if (parent.northwestChild === this) {
            return parent.southwestChild;
        } else if (parent.northeastChild === this) {
            return parent.southeastChild;
        }

        var southOfParent = parent.findTileToSouth(levelZeroTiles);
        if (southOfParent === undefined) {
            return undefined;
        } else if (parent.southwestChild === this) {
            return southOfParent.northwestChild;
        }
        return southOfParent.northeastChild;
    };

    QuadtreeTile.prototype.findTileToNorth = function(levelZeroTiles) {
        var parent = this.parent;
        if (parent === undefined) {
            return this.findLevelZeroTile(levelZeroTiles, this.x, this.y - 1);
        }

        if (parent.southwestChild === this) {
            return parent.northwestChild;
        } else if (parent.southeastChild === this) {
            return parent.northeastChild;
        }

        var northOfParent = parent.findTileToNorth(levelZeroTiles);
        if (northOfParent === undefined) {
            return undefined;
        } else if (parent.northwestChild === this) {
            return northOfParent.southwestChild;
        }
        return northOfParent.southeastChild;
    };

    /**
     * Frees the resources associated with this tile and returns it to the <code>START</code>
     * {@link QuadtreeTileLoadState}.  If the {@link QuadtreeTile#data} property is defined and it
     * has a <code>freeResources</code> method, the method will be invoked.
     *
     * @memberof QuadtreeTile
     */
    QuadtreeTile.prototype.freeResources = function() {
        this.state = QuadtreeTileLoadState.START;
        this.renderable = false;
        this.upsampledFromParent = false;

        if (defined(this.data) && defined(this.data.freeResources)) {
            this.data.freeResources();
        }

        freeTile(this._southwestChild);
        this._southwestChild = undefined;
        freeTile(this._southeastChild);
        this._southeastChild = undefined;
        freeTile(this._northwestChild);
        this._northwestChild = undefined;
        freeTile(this._northeastChild);
        this._northeastChild = undefined;
    };

    function freeTile(tile) {
        if (defined(tile)) {
            tile.freeResources();
        }
    }
export default QuadtreeTile;