import {
  Batched3DModel3DTileContent,
  Cartesian3,
  Cesium3DTile,
  Cesium3DTileRefine,
  Cesium3DTileset,
  Ellipsoid,
  HeadingPitchRange,
  Implicit3DTileContent,
  ImplicitSubdivisionScheme,
  ImplicitTileCoordinates,
  ImplicitTileset,
  Matrix3,
  Matrix4,
  MetadataClass,
  GroupMetadata,
  Multiple3DTileContent,
  Resource,
  TileBoundingSphere,
  TileBoundingS2Cell,
} from "../../Source/Cesium.js";
import CesiumMath from "../../Source/Core/Math.js";
import ImplicitTilingTester from "../ImplicitTilingTester.js";
import Cesium3DTilesTester from "../Cesium3DTilesTester.js";
import createScene from "../createScene.js";

describe(
  "Scene/Implicit3DTileContent",
  function () {
    var tilesetResource = new Resource({
      url: "https://example.com/tileset.json",
    });
    var mockTileset = {
      modelMatrix: Matrix4.IDENTITY,
    };
    var metadataSchema; // intentionally left undefined

    var tileJson = {
      geometricError: 800,
      refine: "ADD",
      boundingVolume: {
        box: [0, 0, 0, 256, 0, 0, 0, 256, 0, 0, 0, 256],
      },
      content: {
        uri: "https://example.com/{level}/{x}/{y}.b3dm",
        extras: {
          author: "Cesium",
        },
      },
      extensions: {
        "3DTILES_implicit_tiling": {
          subdivisionScheme: "QUADTREE",
          subtreeLevels: 2,
          maximumLevel: 1,
          subtrees: {
            uri: "https://example.com/{level}/{x}/{y}.subtree",
          },
        },
      },
      extras: {
        year: "2021",
      },
    };

    var implicitTileset = new ImplicitTileset(
      tilesetResource,
      tileJson,
      metadataSchema
    );

    var quadtreeBuffer = ImplicitTilingTester.generateSubtreeBuffers({
      tileAvailability: {
        descriptor: "11010",
        bitLength: 5,
        isInternal: true,
      },
      contentAvailability: [
        {
          descriptor: "01010",
          bitLength: 5,
          isInternal: true,
        },
      ],
      childSubtreeAvailability: {
        descriptor: "1111000011110000",
        bitLength: 16,
        isInternal: true,
      },
    }).subtreeBuffer;

    var rootCoordinates = new ImplicitTileCoordinates({
      subdivisionScheme: implicitTileset.subdivisionScheme,
      subtreeLevels: implicitTileset.subtreeLevels,
      level: 0,
      x: 0,
      y: 0,
      z: 0,
    });

    function gatherTilesPreorder(tile, minLevel, maxLevel, result) {
      var level = tile.implicitCoordinates.level;
      if (minLevel <= level && level <= maxLevel) {
        result.push(tile);
      }

      for (var i = 0; i < tile.children.length; i++) {
        gatherTilesPreorder(tile.children[i], minLevel, maxLevel, result);
      }
    }

    function getBoundingBoxArray(tile) {
      var boundingBox = tile.boundingVolume.boundingVolume;
      var box = new Array(12);
      Cartesian3.pack(boundingBox.center, box);
      Matrix3.pack(boundingBox.halfAxes, box, 3);
      return box;
    }

    var scene;

    // This scene is the same as Composite/Composite, just rephrased
    // using 3DTILES_multiple_contents
    var centerLongitude = -1.31968;
    var centerLatitude = 0.698874;

    beforeAll(function () {
      scene = createScene();
    });

    afterAll(function () {
      scene.destroyForSpecs();
    });

    var mockPlaceholderTile;
    beforeEach(function () {
      mockPlaceholderTile = new Cesium3DTile(mockTileset, tilesetResource, {
        geometricError: 400,
        boundingVolume: {
          box: [0, 0, 0, 256, 0, 0, 0, 256, 0, 0, 0, 256],
        },
      });
      mockPlaceholderTile.implicitCoordinates = rootCoordinates;
      mockPlaceholderTile.implicitTileset = implicitTileset;

      // One item in each data set is always located in the center, so point the camera there
      var center = Cartesian3.fromRadians(centerLongitude, centerLatitude);
      scene.camera.lookAt(center, new HeadingPitchRange(0.0, -1.57, 26.0));
    });

    afterEach(function () {
      scene.primitives.removeAll();
    });

    it("expands subtree", function () {
      var content = new Implicit3DTileContent(
        mockTileset,
        mockPlaceholderTile,
        tilesetResource,
        quadtreeBuffer,
        0
      );
      return content.readyPromise.then(function () {
        var expectedChildrenCounts = [2, 4, 0, 0, 0, 0, 4, 0, 0, 0, 0];
        var tiles = [];
        var subtreeRootTile = mockPlaceholderTile.children[0];
        gatherTilesPreorder(subtreeRootTile, 0, 2, tiles);
        expect(expectedChildrenCounts.length).toEqual(tiles.length);
        for (var i = 0; i < tiles.length; i++) {
          expect(tiles[i].children.length).toEqual(expectedChildrenCounts[i]);
        }
      });
    });

    it("sets tile coordinates on each tile", function () {
      var content = new Implicit3DTileContent(
        mockTileset,
        mockPlaceholderTile,
        tilesetResource,
        quadtreeBuffer,
        0
      );
      return content.readyPromise.then(function () {
        var expectedCoordinates = [
          [0, 0, 0],
          [1, 0, 0],
          [2, 0, 0],
          [2, 1, 0],
          [2, 0, 1],
          [2, 1, 1],
          [1, 0, 1],
          [2, 0, 2],
          [2, 1, 2],
          [2, 0, 3],
          [2, 1, 3],
        ];
        var tiles = [];
        var subtreeRootTile = mockPlaceholderTile.children[0];
        gatherTilesPreorder(subtreeRootTile, 0, 2, tiles);
        for (var i = 0; i < tiles.length; i++) {
          var expected = expectedCoordinates[i];
          var coordinates = new ImplicitTileCoordinates({
            subdivisionScheme: implicitTileset.subdivisionScheme,
            subtreeLevels: implicitTileset.subtreeLevels,
            level: expected[0],
            x: expected[1],
            y: expected[2],
          });
          expect(tiles[i].implicitCoordinates).toEqual(coordinates);
        }
      });
    });

    it("handles deeper subtrees correctly", function () {
      mockPlaceholderTile.implicitCoordinates = new ImplicitTileCoordinates({
        subdivisionScheme: implicitTileset.subdivisionScheme,
        subtreeLevels: implicitTileset.subtreeLevels,
        level: 2,
        x: 2,
        y: 1,
      });
      var content = new Implicit3DTileContent(
        mockTileset,
        mockPlaceholderTile,
        tilesetResource,
        quadtreeBuffer,
        0
      );
      var refine =
        implicitTileset.refine === "ADD"
          ? Cesium3DTileRefine.ADD
          : Cesium3DTileRefine.REPLACE;

      var parentCoordinates = mockPlaceholderTile.implicitCoordinates;
      var childCoordinates = parentCoordinates.getChildCoordinates(0);

      var parentGeometricError = implicitTileset.geometricError / 4;
      var childGeometricError = implicitTileset.geometricError / 8;

      var rootBoundingVolume = [0, 0, 0, 256, 0, 0, 0, 256, 0, 0, 0, 256];
      var parentBox = Implicit3DTileContent._deriveBoundingBox(
        rootBoundingVolume,
        parentCoordinates.level,
        parentCoordinates.x,
        parentCoordinates.y
      );
      var childBox = Implicit3DTileContent._deriveBoundingBox(
        rootBoundingVolume,
        childCoordinates.level,
        childCoordinates.x,
        childCoordinates.y
      );

      return content.readyPromise.then(function () {
        var subtreeRootTile = mockPlaceholderTile.children[0];
        var childTile = subtreeRootTile.children[0];
        expect(subtreeRootTile.implicitCoordinates).toEqual(parentCoordinates);
        expect(childTile.implicitCoordinates).toEqual(childCoordinates);

        expect(subtreeRootTile.refine).toEqual(refine);
        expect(childTile.refine).toEqual(refine);

        expect(subtreeRootTile.geometricError).toEqual(parentGeometricError);
        expect(childTile.geometricError).toEqual(childGeometricError);

        expect(getBoundingBoxArray(subtreeRootTile)).toEqual(parentBox);
        expect(getBoundingBoxArray(childTile)).toEqual(childBox);
      });
    });

    it("puts the root tile inside the placeholder tile", function () {
      var content = new Implicit3DTileContent(
        mockTileset,
        mockPlaceholderTile,
        tilesetResource,
        quadtreeBuffer,
        0
      );
      return content.readyPromise.then(function () {
        expect(mockPlaceholderTile.children.length).toEqual(1);
      });
    });

    it("preserves tile extras", function () {
      var content = new Implicit3DTileContent(
        mockTileset,
        mockPlaceholderTile,
        tilesetResource,
        quadtreeBuffer,
        0
      );
      return content.readyPromise.then(function () {
        expect(mockPlaceholderTile.children[0].extras).toEqual(tileJson.extras);
      });
    });

    it("stores a reference to the subtree in each transcoded tile", function () {
      var content = new Implicit3DTileContent(
        mockTileset,
        mockPlaceholderTile,
        tilesetResource,
        quadtreeBuffer,
        0
      );
      return content.readyPromise.then(function () {
        expect(mockPlaceholderTile.implicitSubtree).not.toBeDefined();

        var subtreeRootTile = mockPlaceholderTile.children[0];
        var subtree = subtreeRootTile.implicitSubtree;
        expect(subtree).toBeDefined();

        var tiles = [];
        gatherTilesPreorder(subtreeRootTile, 0, 1, tiles);
        for (var i = 0; i < tiles.length; i++) {
          expect(tiles[i].implicitSubtree).toBe(subtree);
        }
      });
    });

    it("does not store references to subtrees in placeholder tiles", function () {
      var content = new Implicit3DTileContent(
        mockTileset,
        mockPlaceholderTile,
        tilesetResource,
        quadtreeBuffer,
        0
      );
      return content.readyPromise.then(function () {
        expect(mockPlaceholderTile.implicitSubtree).not.toBeDefined();

        var subtreeRootTile = mockPlaceholderTile.children[0];

        var tiles = [];
        gatherTilesPreorder(subtreeRootTile, 2, 2, tiles);
        for (var i = 0; i < tiles.length; i++) {
          expect(tiles[i].implicitSubtree).not.toBeDefined();
        }
      });
    });

    it("destroys", function () {
      var content = new Implicit3DTileContent(
        mockTileset,
        mockPlaceholderTile,
        tilesetResource,
        quadtreeBuffer,
        0
      );
      return content.readyPromise.then(function () {
        var subtree = content._implicitSubtree;
        expect(content.isDestroyed()).toBe(false);
        expect(subtree.isDestroyed()).toBe(false);

        content.destroy();
        expect(content.isDestroyed()).toBe(true);
        expect(subtree.isDestroyed()).toBe(true);
      });
    });

    it("returns default values for most Cesium3DTileContent properties", function () {
      var content = new Implicit3DTileContent(
        mockTileset,
        mockPlaceholderTile,
        tilesetResource,
        quadtreeBuffer,
        0
      );

      expect(content.featurePropertiesDirty).toBe(false);
      expect(content.featuresLength).toBe(0);
      expect(content.pointsLength).toBe(0);
      expect(content.trianglesLength).toBe(0);
      expect(content.geometryByteLength).toBe(0);
      expect(content.texturesByteLength).toBe(0);
      expect(content.batchTableByteLength).toBe(0);
      expect(content.innerContents).not.toBeDefined();
      expect(content.tileset).toBe(mockTileset);
      expect(content.tile).toBe(mockPlaceholderTile);
      expect(content.batchTable).not.toBeDefined();
    });

    it("url returns the subtree url", function () {
      var content = new Implicit3DTileContent(
        mockTileset,
        mockPlaceholderTile,
        tilesetResource,
        quadtreeBuffer,
        0
      );
      expect(content.url).toBe("https://example.com/0/0/0.subtree");
    });

    it("templates content URIs for each tile with content", function () {
      var content = new Implicit3DTileContent(
        mockTileset,
        mockPlaceholderTile,
        tilesetResource,
        quadtreeBuffer,
        0
      );
      return content.readyPromise.then(function () {
        var expectedCoordinates = [
          [0, 0, 0],
          [1, 0, 0],
          [1, 0, 1],
        ];
        var contentAvailability = [false, true, true];
        var templateUri = implicitTileset.contentUriTemplates[0];
        var subtreeRootTile = mockPlaceholderTile.children[0];
        var tiles = [];
        gatherTilesPreorder(subtreeRootTile, 0, 1, tiles);
        expect(expectedCoordinates.length).toEqual(tiles.length);
        for (var i = 0; i < tiles.length; i++) {
          var expected = expectedCoordinates[i];
          var coordinates = new ImplicitTileCoordinates({
            subdivisionScheme: implicitTileset.subdivisionScheme,
            subtreeLevels: implicitTileset.subtreeLevels,
            level: expected[0],
            x: expected[1],
            y: expected[2],
          });
          var expectedResource = templateUri.getDerivedResource({
            templateValues: coordinates.getTemplateValues(),
          });
          if (contentAvailability[i]) {
            expect(tiles[i]._contentResource.url).toEqual(expectedResource.url);
          } else {
            expect(tiles[i]._contentResource).not.toBeDefined();
          }
        }
      });
    });

    it("constructs placeholder tiles for child subtrees", function () {
      var content = new Implicit3DTileContent(
        mockTileset,
        mockPlaceholderTile,
        tilesetResource,
        quadtreeBuffer,
        0
      );
      return content.readyPromise.then(function () {
        var expectedCoordinates = [
          [2, 0, 0],
          [2, 1, 0],
          [2, 0, 1],
          [2, 1, 1],
          [2, 0, 2],
          [2, 1, 2],
          [2, 0, 3],
          [2, 1, 3],
        ];
        var templateUri = implicitTileset.subtreeUriTemplate;
        var subtreeRootTile = mockPlaceholderTile.children[0];
        var tiles = [];
        gatherTilesPreorder(subtreeRootTile, 2, 2, tiles);

        expect(expectedCoordinates.length).toEqual(tiles.length);
        for (var i = 0; i < tiles.length; i++) {
          var expected = expectedCoordinates[i];
          var coordinates = new ImplicitTileCoordinates({
            subdivisionScheme: implicitTileset.subdivisionScheme,
            subtreeLevels: implicitTileset.subtreeLevels,
            level: expected[0],
            x: expected[1],
            y: expected[2],
          });
          var expectedResource = templateUri.getDerivedResource({
            templateValues: coordinates.getTemplateValues(),
          });
          var placeholderTile = tiles[i];
          expect(placeholderTile._contentResource.url).toEqual(
            expectedResource.url
          );
          expect(placeholderTile.implicitTileset).toBeDefined();
          expect(placeholderTile.implicitCoordinates).toBeDefined();
        }
      });
    });

    it("propagates refine down the tree", function () {
      var content = new Implicit3DTileContent(
        mockTileset,
        mockPlaceholderTile,
        tilesetResource,
        quadtreeBuffer,
        0
      );
      var refine =
        implicitTileset.refine === "ADD"
          ? Cesium3DTileRefine.ADD
          : Cesium3DTileRefine.REPLACE;
      return content.readyPromise.then(function () {
        var subtreeRootTile = mockPlaceholderTile.children[0];
        var tiles = [];
        gatherTilesPreorder(subtreeRootTile, 0, 2, tiles);
        for (var i = 0; i < tiles.length; i++) {
          expect(tiles[i].refine).toEqual(refine);
        }
      });
    });

    it("divides the geometricError by 2 for each level of the tree", function () {
      var content = new Implicit3DTileContent(
        mockTileset,
        mockPlaceholderTile,
        tilesetResource,
        quadtreeBuffer,
        0
      );
      var rootGeometricError = implicitTileset.geometricError;
      return content.readyPromise.then(function () {
        var subtreeRootTile = mockPlaceholderTile.children[0];
        var tiles = [];
        gatherTilesPreorder(subtreeRootTile, 0, 2, tiles);
        for (var i = 0; i < tiles.length; i++) {
          var level = tiles[i].implicitCoordinates.level;
          expect(tiles[i].geometricError).toEqual(
            rootGeometricError / Math.pow(2, level)
          );
        }
      });
    });

    it("subdivides bounding volumes for each tile", function () {
      var content = new Implicit3DTileContent(
        mockTileset,
        mockPlaceholderTile,
        tilesetResource,
        quadtreeBuffer,
        0
      );
      return content.readyPromise.then(function () {
        var expectedCoordinates = [
          [0, 0, 0],
          [1, 0, 0],
          [2, 0, 0],
          [2, 1, 0],
          [2, 0, 1],
          [2, 1, 1],
          [1, 0, 1],
          [2, 0, 2],
          [2, 1, 2],
          [2, 0, 3],
          [2, 1, 3],
        ];
        var rootBoundingVolume = [0, 0, 0, 256, 0, 0, 0, 256, 0, 0, 0, 256];

        var subtreeRootTile = mockPlaceholderTile.children[0];
        var tiles = [];
        gatherTilesPreorder(subtreeRootTile, 0, 2, tiles);

        expect(expectedCoordinates.length).toEqual(tiles.length);
        for (var i = 0; i < tiles.length; i++) {
          var coordinates = expectedCoordinates[i];

          var boundingBox = tiles[i].boundingVolume.boundingVolume;
          var childBox = new Array(12);
          Cartesian3.pack(boundingBox.center, childBox);
          Matrix3.pack(boundingBox.halfAxes, childBox, 3);

          var expectedBounds = Implicit3DTileContent._deriveBoundingBox(
            rootBoundingVolume,
            coordinates[0],
            coordinates[1],
            coordinates[2]
          );
          expect(childBox).toEqual(expectedBounds);
        }
      });
    });

    describe("_deriveBoundingVolumeS2", function () {
      var deriveBoundingVolumeS2 =
        Implicit3DTileContent._deriveBoundingVolumeS2;
      var simpleBoundingVolumeS2 = {
        token: "1",
        minimumHeight: 0,
        maximumHeight: 10,
      };
      var simpleBoundingVolumeS2Cell = new TileBoundingS2Cell(
        simpleBoundingVolumeS2
      );
      var implicitTilesetS2 = {
        boundingVolume: {
          extensions: {
            "3DTILES_bounding_volume_S2": simpleBoundingVolumeS2,
          },
        },
        subdivisionScheme: ImplicitSubdivisionScheme.QUADTREE,
      };

      it("throws if parentIsPlaceholderTile is undefined", function () {
        expect(function () {
          deriveBoundingVolumeS2(undefined, {}, 0, 0, 0, 0, 0);
        }).toThrowDeveloperError();
      });

      it("throws if parentTile is undefined", function () {
        expect(function () {
          deriveBoundingVolumeS2(false, undefined, 0, 0, 0, 0, 0);
        }).toThrowDeveloperError();
      });

      it("throws if childIndex is undefined", function () {
        expect(function () {
          deriveBoundingVolumeS2(false, {}, undefined, 0, 0, 0, 0);
        }).toThrowDeveloperError();
      });

      it("throws if level is undefined", function () {
        expect(function () {
          deriveBoundingVolumeS2(false, {}, 0, undefined, 0, 0, 0);
        }).toThrowDeveloperError();
      });

      it("throws if x is undefined", function () {
        expect(function () {
          deriveBoundingVolumeS2(false, {}, 0, 0, undefined, 0, 0);
        }).toThrowDeveloperError();
      });

      it("throws if y is undefined", function () {
        expect(function () {
          deriveBoundingVolumeS2(false, {}, 0, 0, 0, undefined, 0);
        }).toThrowDeveloperError();
      });

      it("throws if z is defined but not a number", function () {
        expect(function () {
          deriveBoundingVolumeS2(false, {}, 0, 0, 0, 0, "");
        }).toThrowDeveloperError();
      });

      it("returns implicit tileset boundingVolume if parentIsPlaceholderTile is true", function () {
        var placeholderTile = {
          _boundingVolume: simpleBoundingVolumeS2Cell,
        };
        var result = deriveBoundingVolumeS2(
          true,
          placeholderTile,
          0,
          0,
          0,
          0,
          0
        );
        expect(result).toEqual(implicitTilesetS2.boundingVolume);
        expect(result).not.toBe(implicitTilesetS2.boundingVolume);
      });

      it("subdivides correctly using QUADTREE", function () {
        var parentTile = {
          _boundingVolume: simpleBoundingVolumeS2Cell,
        };
        var expected = {
          token: "04",
          minimumHeight: 0,
          maximumHeight: 10,
        };
        var result = deriveBoundingVolumeS2(false, parentTile, 0, 1, 0, 0);
        expect(result).toEqual({
          extensions: {
            "3DTILES_bounding_volume_S2": expected,
          },
        });

        parentTile._boundingVolume = new TileBoundingS2Cell({
          token: "3",
          minimumHeight: 0,
          maximumHeight: 10,
        });
        expected = {
          token: "24",
          minimumHeight: 0,
          maximumHeight: 10,
        };
        result = deriveBoundingVolumeS2(false, parentTile, 0, 1, 0, 0);
        expect(result).toEqual({
          extensions: {
            "3DTILES_bounding_volume_S2": expected,
          },
        });
      });

      it("subdivides correctly using OCTREE", function () {
        implicitTilesetS2.subdivisionScheme = ImplicitSubdivisionScheme.OCTREE;
        var parentTile = {
          _boundingVolume: simpleBoundingVolumeS2Cell,
        };
        var expected0 = {
          token: "04",
          minimumHeight: 0,
          maximumHeight: 5,
        };
        var expected1 = {
          token: "04",
          minimumHeight: 5,
          maximumHeight: 10,
        };
        var result0 = deriveBoundingVolumeS2(false, parentTile, 0, 1, 0, 0, 0);
        expect(result0).toEqual({
          extensions: {
            "3DTILES_bounding_volume_S2": expected0,
          },
        });
        var result1 = deriveBoundingVolumeS2(false, parentTile, 4, 1, 0, 0, 0);
        expect(result1).toEqual({
          extensions: {
            "3DTILES_bounding_volume_S2": expected1,
          },
        });
      });
    });

    describe("_deriveBoundingBox", function () {
      var deriveBoundingBox = Implicit3DTileContent._deriveBoundingBox;
      var simpleBoundingBox = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1];
      it("throws if rootBox is undefined", function () {
        expect(function () {
          deriveBoundingBox(undefined, 0, 0, 0);
        }).toThrowDeveloperError();
      });

      it("throws if level is undefined", function () {
        expect(function () {
          deriveBoundingBox(simpleBoundingBox, undefined, 0, 0);
        }).toThrowDeveloperError();
      });

      it("throws if x is undefined", function () {
        expect(function () {
          deriveBoundingBox(simpleBoundingBox, 1, undefined, 0);
        }).toThrowDeveloperError();
      });

      it("throws if y is undefined", function () {
        expect(function () {
          deriveBoundingBox(simpleBoundingBox, 1, 0, undefined);
        }).toThrowDeveloperError();
      });

      it("subdivides like a quadtree if z is not given", function () {
        var tile = [1, 3, 0, 4, 0, 0, 0, 2, 0, 0, 0, 1];
        var expected = [0, 1.5, 0, 1, 0, 0, 0, 0.5, 0, 0, 0, 1];
        var result = deriveBoundingBox(tile, 2, 1, 0);
        expect(result).toEqual(expected);
      });

      it("subdivides like an octree if z is given", function () {
        var tile = [1, 3, 0, 4, 0, 0, 0, 2, 0, 0, 0, 1];
        var expected = [0, 1.5, 0.25, 1, 0, 0, 0, 0.5, 0, 0, 0, 0.25];
        var result = deriveBoundingBox(tile, 2, 1, 0, 2);
        expect(result).toEqual(expected);
      });

      it("handles rotation and non-uniform scaling correctly", function () {
        var tile = [1, 2, 3, 0, 4, 0, 0, 0, 2, 1, 0, 0];
        var expected = [1.25, 1, 1.5, 0, 1, 0, 0, 0, 0.5, 0.25, 0, 0];
        var result = deriveBoundingBox(tile, 2, 1, 0, 2);
        expect(result).toEqual(expected);
      });
    });

    describe("_deriveBoundingRegion", function () {
      var deriveBoundingRegion = Implicit3DTileContent._deriveBoundingRegion;
      var simpleRegion = [
        0,
        0,
        CesiumMath.PI_OVER_FOUR,
        CesiumMath.PI_OVER_FOUR,
        0,
        100,
      ];
      it("throws if rootRegion is undefined", function () {
        expect(function () {
          deriveBoundingRegion(undefined, 1, 0, 0);
        }).toThrowDeveloperError();
      });

      it("throws if level is undefined", function () {
        expect(function () {
          deriveBoundingRegion(simpleRegion, undefined, 0, 0);
        }).toThrowDeveloperError();
      });

      it("throws if x is undefined", function () {
        expect(function () {
          deriveBoundingRegion(simpleRegion, 1, undefined, 0);
        }).toThrowDeveloperError();
      });

      it("throws if y is undefined", function () {
        expect(function () {
          deriveBoundingRegion(simpleRegion, 1, 0, undefined);
        }).toThrowDeveloperError();
      });

      function makeRectangle(
        westDegrees,
        southDegrees,
        eastDegrees,
        northDegrees,
        minimumHeight,
        maximumHeight
      ) {
        return [
          CesiumMath.toRadians(westDegrees),
          CesiumMath.toRadians(southDegrees),
          CesiumMath.toRadians(eastDegrees),
          CesiumMath.toRadians(northDegrees),
          minimumHeight,
          maximumHeight,
        ];
      }

      it("subdivides like a quadtree if z is not given", function () {
        // 4x4 degree rectangle so the subdivisions at level 2 will
        // be 1 degree each
        var tile = makeRectangle(-1, -2, 3, 2, 0, 20);
        var expected = makeRectangle(0, 1, 1, 2, 0, 20);

        var result = deriveBoundingRegion(tile, 2, 1, 3);
        expect(result).toEqualEpsilon(expected, CesiumMath.EPSILON9);
      });

      it("deriveVolume subdivides like an octree if z is given", function () {
        // 4x4 degree rectangle so the subdivisions at level 2 will
        // be 1 degree each
        var tile = makeRectangle(-1, -2, 3, 2, 0, 20);
        var expected = makeRectangle(0, 1, 1, 2, 10, 15);

        var result = deriveBoundingRegion(tile, 2, 1, 3, 2);
        expect(result).toEqualEpsilon(expected, CesiumMath.EPSILON9);
      });

      it("handles the IDL", function () {
        var tile = makeRectangle(90, -45, -90, 45, 0, 20);
        var expected = makeRectangle(180, -45, -90, 0, 0, 20);

        var result = deriveBoundingRegion(tile, 1, 1, 0);
        expect(result).toEqualEpsilon(expected, CesiumMath.EPSILON9);
      });
    });

    describe("3DTILES_multiple_contents", function () {
      var implicitMultipleContentsUrl =
        "Data/Cesium3DTiles/Implicit/ImplicitMultipleContents/tileset.json";

      it("a single content is transcoded as a regular tile", function () {
        return Cesium3DTilesTester.loadTileset(
          scene,
          implicitMultipleContentsUrl
        ).then(function (tileset) {
          // The root tile of this tileset only has one available content
          var transcodedRoot = tileset.root.children[0];
          var transcodedRootHeader = transcodedRoot._header;
          expect(transcodedRoot.content).toBeInstanceOf(
            Batched3DModel3DTileContent
          );
          expect(transcodedRootHeader.content).toEqual({
            uri: "ground/0/0/0.b3dm",
          });
          expect(transcodedRootHeader.extensions).not.toBeDefined();
        });
      });

      it("multiple contents are transcoded to a tile with a 3DTILES_multiple_contents extension", function () {
        return Cesium3DTilesTester.loadTileset(
          scene,
          implicitMultipleContentsUrl
        ).then(function (tileset) {
          var childTiles = tileset.root.children[0].children;
          for (var i = 0; i < childTiles.length; i++) {
            var childTile = childTiles[i];
            var content = childTile.content;
            expect(content).toBeInstanceOf(Multiple3DTileContent);

            var childTileHeader = childTile._header;
            expect(childTileHeader.content).not.toBeDefined();
          }
        });
      });

      it("passes extensions through correctly", function () {
        var originalLoadJson = Cesium3DTileset.loadJson;
        var metadataExtension = {
          group: "buildings",
        };
        var otherExtension = {
          someKey: "someValue",
        };

        spyOn(Cesium3DTileset, "loadJson").and.callFake(function (tilesetUrl) {
          return originalLoadJson(tilesetUrl).then(function (tilesetJson) {
            var multiContent =
              tilesetJson.root.extensions["3DTILES_multiple_contents"];
            multiContent.content.forEach(function (content) {
              content.extensions = {
                "3DTILES_metadata": metadataExtension,
              };
            });

            tilesetJson.root.extensions["3DTILES_extension"] = otherExtension;
            return tilesetJson;
          });
        });

        return Cesium3DTilesTester.loadTileset(
          scene,
          implicitMultipleContentsUrl
        ).then(function (tileset) {
          // the placeholder tile does not have any extensions.
          var placeholderTile = tileset.root;
          var placeholderHeader = placeholderTile._header;
          expect(placeholderHeader.extensions).not.toBeDefined();
          expect(placeholderHeader.content.extensions).not.toBeDefined();

          var transcodedRoot = placeholderTile.children[0];
          var transcodedRootHeader = transcodedRoot._header;
          expect(transcodedRootHeader.extensions).toEqual({
            "3DTILES_extension": otherExtension,
          });
          expect(transcodedRootHeader.content.extensions).toEqual({
            "3DTILES_metadata": metadataExtension,
          });

          var childTiles = transcodedRoot.children;
          for (var i = 0; i < childTiles.length; i++) {
            var childTile = childTiles[i];

            var childTileHeader = childTile._header;
            expect(childTileHeader.extensions["3DTILES_extension"]).toEqual(
              otherExtension
            );

            var innerContentHeaders =
              childTileHeader.extensions["3DTILES_multiple_contents"].content;

            innerContentHeaders.forEach(function (header) {
              expect(header.extensions).toEqual({
                "3DTILES_metadata": metadataExtension,
              });
            });
          }
        });
      });
    });

    describe("3DTILES_metadata", function () {
      var implicitTilesetUrl =
        "Data/Cesium3DTiles/Implicit/ImplicitTileset/tileset.json";
      var implicitGroupMetadataUrl =
        "Data/Cesium3DTiles/Metadata/ImplicitGroupMetadata/tileset.json";
      var implicitHeightSemanticsUrl =
        "Data/Cesium3DTiles/Metadata/ImplicitHeightSemantics/tileset.json";
      var implicitS2HeightSemanticsUrl =
        "Data/Cesium3DTiles/Metadata/ImplicitHeightSemantics/s2-tileset.json";
      var implicitTileBoundingVolumeSemanticsUrl =
        "Data/Cesium3DTiles/Metadata/ImplicitTileBoundingVolumeSemantics/tileset.json";
      var implicitHeightAndSphereSemanticsUrl =
        "Data/Cesium3DTiles/Metadata/ImplicitHeightAndSphereSemantics/tileset.json";
      var implicitHeightAndRegionSemanticsUrl =
        "Data/Cesium3DTiles/Metadata/ImplicitHeightAndRegionSemantics/tileset.json";
      var implicitContentBoundingVolumeSemanticsUrl =
        "Data/Cesium3DTiles/Metadata/ImplicitContentBoundingVolumeSemantics/tileset.json";
      var implicitContentHeightSemanticsUrl =
        "Data/Cesium3DTiles/Metadata/ImplicitContentHeightSemantics/tileset.json";
      var implicitContentHeightAndRegionSemanticsUrl =
        "Data/Cesium3DTiles/Metadata/ImplicitContentHeightAndRegionSemantics/tileset.json";
      var implicitGeometricErrorSemanticsUrl =
        "Data/Cesium3DTiles/Metadata/ImplicitGeometricErrorSemantics/tileset.json";

      var metadataClass = new MetadataClass({
        id: "test",
        class: {
          properties: {
            name: {
              componentType: "STRING",
            },
            height: {
              componentType: "FLOAT32",
            },
          },
        },
      });
      var groupMetadata = new GroupMetadata({
        id: "testGroup",
        group: {
          properties: {
            name: "Test Group",
            height: 35.6,
          },
        },
        class: metadataClass,
      });

      it("assigns groupMetadata", function () {
        return Cesium3DTilesTester.loadTileset(scene, implicitTilesetUrl).then(
          function (tileset) {
            var content = tileset.root.content;
            content.groupMetadata = groupMetadata;
            expect(content.groupMetadata).toBe(groupMetadata);
          }
        );
      });

      it("group metadata gets transcoded correctly", function () {
        return Cesium3DTilesTester.loadTileset(
          scene,
          implicitGroupMetadataUrl
        ).then(function (tileset) {
          var placeholderTile = tileset.root;
          var subtreeRootTile = placeholderTile.children[0];
          var tiles = [];
          gatherTilesPreorder(subtreeRootTile, 0, 2, tiles);

          var groups = tileset.metadata.groups;
          var ground = groups.ground;
          expect(ground.getProperty("color")).toEqual(
            new Cartesian3(120, 68, 32)
          );
          expect(ground.getProperty("priority")).toBe(0);

          var sky = groups.sky;
          expect(sky.getProperty("color")).toEqual(
            new Cartesian3(206, 237, 242)
          );
          expect(sky.getProperty("priority")).toBe(1);

          tiles.forEach(function (tile) {
            if (tile.hasMultipleContents) {
              // child tiles have multiple contents
              var contents = tile.content.innerContents;
              expect(contents[0].groupMetadata).toBe(ground);
              expect(contents[1].groupMetadata).toBe(sky);
            } else {
              // parent tile is a single B3DM tile
              expect(tile.content.groupMetadata).toBe(ground);
            }
          });
        });
      });

      // view (lon, lat, height) = (0, 0, 0) from height meters above
      function viewCartographicOrigin(height) {
        var center = Cartesian3.fromDegrees(0.0, 0.0);
        var offset = new Cartesian3(0, 0, height);
        scene.camera.lookAt(center, offset);
      }

      it("uses height semantics to adjust region bounding volumes", function () {
        viewCartographicOrigin(10000);
        return Cesium3DTilesTester.loadTileset(
          scene,
          implicitHeightSemanticsUrl
        ).then(function (tileset) {
          var placeholderTile = tileset.root;
          var subtreeRootTile = placeholderTile.children[0];

          var implicitRegion =
            placeholderTile.implicitTileset.boundingVolume.region;
          var minimumHeight = implicitRegion[4];
          var maximumHeight = implicitRegion[5];

          // This tileset uses TILE_MINIMUM_HEIGHT and TILE_MAXIMUM_HEIGHT
          // to set tighter bounding volumes
          var tiles = [];
          gatherTilesPreorder(subtreeRootTile, 0, 3, tiles);
          for (var i = 0; i < tiles.length; i++) {
            var tileRegion = tiles[i].boundingVolume;
            expect(tileRegion.minimumHeight).toBeGreaterThan(minimumHeight);
            expect(tileRegion.maximumHeight).toBeLessThan(maximumHeight);
          }
        });
      });

      it("uses height semantics to adjust S2 bounding volumes", function () {
        viewCartographicOrigin(10000);
        return Cesium3DTilesTester.loadTileset(
          scene,
          implicitS2HeightSemanticsUrl
        ).then(function (tileset) {
          var placeholderTile = tileset.root;
          var subtreeRootTile = placeholderTile.children[0];

          var implicitS2Volume =
            placeholderTile.implicitTileset.boundingVolume.extensions[
              "3DTILES_bounding_volume_S2"
            ];
          var minimumHeight = implicitS2Volume.minimumHeight;
          var maximumHeight = implicitS2Volume.maximumHeight;

          // This tileset uses TILE_MINIMUM_HEIGHT and TILE_MAXIMUM_HEIGHT
          // to set tighter bounding volumes
          var tiles = [];
          gatherTilesPreorder(subtreeRootTile, 0, 3, tiles);
          for (var i = 0; i < tiles.length; i++) {
            var tileS2Volume = tiles[i].boundingVolume;
            expect(tileS2Volume.minimumHeight).toBeGreaterThan(minimumHeight);
            expect(tileS2Volume.maximumHeight).toBeLessThan(maximumHeight);
          }
        });
      });

      // get half the bounding cube width from the bounding box's
      // halfAxes matrix
      function getHalfWidth(boundingBox) {
        return boundingBox.boundingVolume.halfAxes[0];
      }

      it("ignores height semantics if the implicit volume is a box", function () {
        var cameraHeight = 100;
        var rootHalfWidth = 10;
        var originalLoadJson = Cesium3DTileset.loadJson;
        spyOn(Cesium3DTileset, "loadJson").and.callFake(function (tilesetUrl) {
          return originalLoadJson(tilesetUrl).then(function (tilesetJson) {
            tilesetJson.root.boundingVolume = {
              box: [
                Ellipsoid.WGS84.radii.x + cameraHeight,
                0,
                0,
                rootHalfWidth,
                0,
                0,
                0,
                rootHalfWidth,
                0,
                0,
                0,
                rootHalfWidth,
              ],
            };
            return tilesetJson;
          });
        });

        viewCartographicOrigin(cameraHeight);
        return Cesium3DTilesTester.loadTileset(
          scene,
          implicitHeightSemanticsUrl
        ).then(function (tileset) {
          var placeholderTile = tileset.root;
          var subtreeRootTile = placeholderTile.children[0];

          var tiles = [];
          gatherTilesPreorder(subtreeRootTile, 0, 3, tiles);

          // TILE_MINIMUM_HEIGHT and TILE_MAXIMUM_HEIGHT only apply to
          // regions, so this will check that they are not used.
          tiles.forEach(function (tile) {
            var level = tile.implicitCoordinates.level;
            var halfWidth = getHalfWidth(tile.boundingVolume);
            // Even for floats, divide by 2 operations are exact as long
            // as there is no overflow.
            expect(halfWidth).toEqual(rootHalfWidth / Math.pow(2, level));
          });
        });
      });

      it("uses tile bounding box from metadata semantics if present", function () {
        viewCartographicOrigin(124000);
        return Cesium3DTilesTester.loadTileset(
          scene,
          implicitTileBoundingVolumeSemanticsUrl
        ).then(function (tileset) {
          var placeholderTile = tileset.root.children[0];
          var subtreeRootTile = placeholderTile.children[0];

          var rootHalfWidth = 2048;
          expect(getHalfWidth(subtreeRootTile.boundingVolume)).toBe(
            rootHalfWidth
          );

          for (var level = 1; level < 4; level++) {
            var halfWidthAtLevel = rootHalfWidth / (1 << level);
            var tiles = [];
            gatherTilesPreorder(subtreeRootTile, level, level, tiles);
            for (var i = 0; i < tiles.length; i++) {
              // In this tileset, each tile's TILE_BOUNDING_BOX is
              // smaller than the implicit tile bounds. Make sure
              // this is true.
              var tile = tiles[i];
              var halfWidth = getHalfWidth(tile.boundingVolume);
              expect(halfWidth).toBeLessThan(halfWidthAtLevel);
            }
          }
        });
      });

      it("prioritizes height semantics over bounding volume semantics", function () {
        viewCartographicOrigin(10000);
        return Cesium3DTilesTester.loadTileset(
          scene,
          implicitHeightAndSphereSemanticsUrl
        ).then(function (tileset) {
          var placeholderTile = tileset.root;
          var subtreeRootTile = placeholderTile.children[0];

          var implicitRegion =
            placeholderTile.implicitTileset.boundingVolume.region;

          var minimumHeight = implicitRegion[4];
          var maximumHeight = implicitRegion[5];

          // This tileset uses TILE_BOUNDING_SPHERE, TILE_MINIMUM_HEIGHT, and
          // TILE_MAXIMUM_HEIGHT but TILE_BOUNDING_SPHERE is ignored
          var tiles = [];
          gatherTilesPreorder(subtreeRootTile, 0, 3, tiles);
          for (var i = 0; i < tiles.length; i++) {
            var tileRegion = tiles[i].boundingVolume;
            expect(tileRegion.minimumHeight).toBeDefined();
            expect(tileRegion.maximumHeight).toBeDefined();
            expect(tileRegion.minimumHeight).toBeGreaterThan(minimumHeight);
            expect(tileRegion.maximumHeight).toBeLessThan(maximumHeight);
          }
        });
      });

      it("uses height semantics to adjust region semantic", function () {
        viewCartographicOrigin(10000);
        return Cesium3DTilesTester.loadTileset(
          scene,
          implicitHeightAndRegionSemanticsUrl
        ).then(function (tileset) {
          var placeholderTile = tileset.root;
          var subtreeRootTile = placeholderTile.children[0];

          var implicitRegion =
            placeholderTile.implicitTileset.boundingVolume.region;

          var west = implicitRegion[0];
          var south = implicitRegion[1];
          var east = implicitRegion[2];
          var north = implicitRegion[3];
          var minimumHeight = implicitRegion[4];
          var maximumHeight = implicitRegion[5];

          // This tileset uses TILE_BOUNDING_REGION, TILE_MINIMUM_HEIGHT, and
          // TILE_MAXIMUM_HEIGHT to set tighter bounding volumes
          var tiles = [];
          gatherTilesPreorder(subtreeRootTile, 0, 3, tiles);
          for (var i = 0; i < tiles.length; i++) {
            var tileRegion = tiles[i].boundingVolume;
            expect(tileRegion.minimumHeight).toBeGreaterThan(minimumHeight);
            expect(tileRegion.maximumHeight).toBeLessThan(maximumHeight);
            // Check that the bounding volume is using the explicit tile regions
            // which are shrunken compared to the implicit tile regions
            expect(tileRegion.rectangle.west).toBeGreaterThan(west);
            expect(tileRegion.rectangle.south).toBeGreaterThan(south);
            expect(tileRegion.rectangle.east).toBeLessThan(east);
            expect(tileRegion.rectangle.north).toBeLessThan(north);
          }
        });
      });

      it("uses content bounding box from metadata semantics if present", function () {
        viewCartographicOrigin(124000);
        return Cesium3DTilesTester.loadTileset(
          scene,
          implicitContentBoundingVolumeSemanticsUrl
        ).then(function (tileset) {
          var placeholderTile = tileset.root.children[0];
          var subtreeRootTile = placeholderTile.children[0];

          // This tileset defines the content bounding spheres in a
          // property with metadata semantic CONTENT_BOUNDING_SPHERE.
          // Check that each tile has a content bounding volume.
          var tiles = [];
          gatherTilesPreorder(subtreeRootTile, 0, 3, tiles);
          tiles.forEach(function (tile) {
            expect(
              tile.contentBoundingVolume instanceof TileBoundingSphere
            ).toBe(true);
            expect(tile.contentBoundingVolume).not.toBe(tile.boundingVolume);
          });
        });
      });

      it("uses content height semantics to adjust implicit region", function () {
        viewCartographicOrigin(10000);
        return Cesium3DTilesTester.loadTileset(
          scene,
          implicitContentHeightSemanticsUrl
        ).then(function (tileset) {
          var placeholderTile = tileset.root;
          var subtreeRootTile = placeholderTile.children[0];

          var implicitRegion =
            placeholderTile.implicitTileset.boundingVolume.region;

          var minimumHeight = implicitRegion[4];
          var maximumHeight = implicitRegion[5];

          // This tileset uses CONTENT_MINIMUM_HEIGHT and CONTENT_MAXIMUM_HEIGHT
          // to set tighter bounding volumes
          var tiles = [];
          gatherTilesPreorder(subtreeRootTile, 0, 3, tiles);
          for (var i = 0; i < tiles.length; i++) {
            var contentRegion = tiles[i].contentBoundingVolume;
            expect(contentRegion.minimumHeight).toBeGreaterThan(minimumHeight);
            expect(contentRegion.maximumHeight).toBeLessThan(maximumHeight);
          }
        });
      });

      it("uses content height semantics to adjust content region semantic", function () {
        viewCartographicOrigin(10000);
        return Cesium3DTilesTester.loadTileset(
          scene,
          implicitContentHeightAndRegionSemanticsUrl
        ).then(function (tileset) {
          var placeholderTile = tileset.root;
          var subtreeRootTile = placeholderTile.children[0];

          var implicitRegion =
            placeholderTile.implicitTileset.boundingVolume.region;

          var west = implicitRegion[0];
          var south = implicitRegion[1];
          var east = implicitRegion[2];
          var north = implicitRegion[3];
          var minimumHeight = implicitRegion[4];
          var maximumHeight = implicitRegion[5];

          // This tileset uses CONTENT_BOUNDING_REGION, CONTENT_MINIMUM_HEIGHT, and
          // CONTENT_MAXIMUM_HEIGHT to set tighter bounding volumes
          var tiles = [];
          gatherTilesPreorder(subtreeRootTile, 0, 3, tiles);
          for (var i = 0; i < tiles.length; i++) {
            var contentRegion = tiles[i].contentBoundingVolume;
            expect(contentRegion.minimumHeight).toBeGreaterThan(minimumHeight);
            expect(contentRegion.maximumHeight).toBeLessThan(maximumHeight);
            // Check that the content bounding volume is using the explicit tile
            // regions which are shrunken compared to the implicit tile regions
            expect(contentRegion.rectangle.west).toBeGreaterThan(west);
            expect(contentRegion.rectangle.south).toBeGreaterThan(south);
            expect(contentRegion.rectangle.east).toBeLessThan(east);
            expect(contentRegion.rectangle.north).toBeLessThan(north);
          }
        });
      });

      it("uses geometric error from metadata semantics if present", function () {
        viewCartographicOrigin(10000);
        return Cesium3DTilesTester.loadTileset(
          scene,
          implicitGeometricErrorSemanticsUrl
        ).then(function (tileset) {
          var placeholderTile = tileset.root;
          var subtreeRootTile = placeholderTile.children[0];

          // This tileset defines the geometric error in a
          // property with metadata semantic TILE_GEOMETRIC_ERROR.
          // Check that each tile has the right geometric error.
          var tiles = [];
          gatherTilesPreorder(subtreeRootTile, 0, 3, tiles);
          var geometricErrors = tiles.map(function (tile) {
            return tile.geometricError;
          });
          // prettier-ignore
          var expectedGeometricErrors = [
            300, 203, 112, 113, 114, 115, 201, 104, 105, 106,
            107, 202, 108, 109, 110, 111, 200, 103, 101, 102, 100
          ];
          expect(geometricErrors).toEqual(expectedGeometricErrors);
        });
      });
    });
  },
  "WebGL"
);