import { GeographicTilingScheme } from "../../Source/Cesium.js";
import { Math as CesiumMath } from "../../Source/Cesium.js";
import { Rectangle } from "../../Source/Cesium.js";
import { WebMercatorTilingScheme } from "../../Source/Cesium.js";
import { QuadtreeTile } from "../../Source/Cesium.js";

describe("Scene/QuadtreeTile", function () {
  it("throws without a options", function () {
    expect(function () {
      return new QuadtreeTile();
    }).toThrowDeveloperError();
  });

  it("throws without options.rectangle", function () {
    expect(function () {
      return new QuadtreeTile({
        x: 0,
        y: 0,
      });
    }).toThrowDeveloperError();
  });

  it("throws without options.level", function () {
    expect(function () {
      return new QuadtreeTile({
        rectangle: new Rectangle(
          -CesiumMath.PI_OVER_FOUR,
          0.0,
          CesiumMath.PI_OVER_FOUR,
          CesiumMath.PI_OVER_FOUR
        ),
        x: 0,
        y: 0,
      });
    }).toThrowDeveloperError();
  });

  it("throws with negative x or y properties", function () {
    expect(function () {
      return new QuadtreeTile({
        x: -1.0,
        y: -1.0,
        level: 1.0,
      });
    }).toThrowDeveloperError();
  });

  it("creates rectangle on construction", function () {
    var desc = {
      tilingScheme: new WebMercatorTilingScheme(),
      x: 0,
      y: 0,
      level: 0,
    };
    var tile = new QuadtreeTile(desc);
    var rectangle = desc.tilingScheme.tileXYToRectangle(
      desc.x,
      desc.y,
      desc.level
    );
    expect(tile.rectangle).toEqual(rectangle);
  });

  it("throws if constructed improperly", function () {
    expect(function () {
      return new QuadtreeTile();
    }).toThrowDeveloperError();

    expect(function () {
      return new QuadtreeTile({
        y: 0,
        level: 0,
        tilingScheme: {
          tileXYToRectangle: function () {
            return undefined;
          },
        },
      });
    }).toThrowDeveloperError();

    expect(function () {
      return new QuadtreeTile({
        x: 0,
        level: 0,
        tilingScheme: {
          tileXYToRectangle: function () {
            return undefined;
          },
        },
      });
    }).toThrowDeveloperError();

    expect(function () {
      return new QuadtreeTile({
        x: 0,
        y: 0,
        tilingScheme: {
          tileXYToRectangle: function () {
            return undefined;
          },
        },
      });
    }).toThrowDeveloperError();

    expect(function () {
      return new QuadtreeTile({
        x: 0,
        y: 0,
        level: 0,
      });
    }).toThrowDeveloperError();
  });

  it("can get tiles around a root tile", function () {
    var tilingScheme = new GeographicTilingScheme({
      numberOfLevelZeroTilesX: 3,
      numberOfLevelZeroTilesY: 3,
    });
    var levelZeroTiles = QuadtreeTile.createLevelZeroTiles(tilingScheme);

    var L0X0Y0 = levelZeroTiles.filter(function (tile) {
      return tile.x === 0 && tile.y === 0;
    })[0];
    var L0X1Y0 = levelZeroTiles.filter(function (tile) {
      return tile.x === 1 && tile.y === 0;
    })[0];
    var L0X2Y0 = levelZeroTiles.filter(function (tile) {
      return tile.x === 2 && tile.y === 0;
    })[0];
    var L0X0Y1 = levelZeroTiles.filter(function (tile) {
      return tile.x === 0 && tile.y === 1;
    })[0];
    var L0X1Y1 = levelZeroTiles.filter(function (tile) {
      return tile.x === 1 && tile.y === 1;
    })[0];
    var L0X2Y1 = levelZeroTiles.filter(function (tile) {
      return tile.x === 2 && tile.y === 1;
    })[0];
    var L0X0Y2 = levelZeroTiles.filter(function (tile) {
      return tile.x === 0 && tile.y === 2;
    })[0];
    var L0X1Y2 = levelZeroTiles.filter(function (tile) {
      return tile.x === 1 && tile.y === 2;
    })[0];
    var L0X2Y2 = levelZeroTiles.filter(function (tile) {
      return tile.x === 2 && tile.y === 2;
    })[0];

    expect(L0X0Y0.findTileToWest(levelZeroTiles)).toBe(L0X2Y0);
    expect(L0X0Y0.findTileToEast(levelZeroTiles)).toBe(L0X1Y0);
    expect(L0X0Y0.findTileToNorth(levelZeroTiles)).toBeUndefined();
    expect(L0X0Y0.findTileToSouth(levelZeroTiles)).toBe(L0X0Y1);

    expect(L0X1Y0.findTileToWest(levelZeroTiles)).toBe(L0X0Y0);
    expect(L0X1Y0.findTileToEast(levelZeroTiles)).toBe(L0X2Y0);
    expect(L0X1Y0.findTileToNorth(levelZeroTiles)).toBeUndefined();
    expect(L0X1Y0.findTileToSouth(levelZeroTiles)).toBe(L0X1Y1);

    expect(L0X2Y0.findTileToWest(levelZeroTiles)).toBe(L0X1Y0);
    expect(L0X2Y0.findTileToEast(levelZeroTiles)).toBe(L0X0Y0);
    expect(L0X2Y0.findTileToNorth(levelZeroTiles)).toBeUndefined();
    expect(L0X2Y0.findTileToSouth(levelZeroTiles)).toBe(L0X2Y1);

    expect(L0X0Y1.findTileToWest(levelZeroTiles)).toBe(L0X2Y1);
    expect(L0X0Y1.findTileToEast(levelZeroTiles)).toBe(L0X1Y1);
    expect(L0X0Y1.findTileToNorth(levelZeroTiles)).toBe(L0X0Y0);
    expect(L0X0Y1.findTileToSouth(levelZeroTiles)).toBe(L0X0Y2);

    expect(L0X1Y1.findTileToWest(levelZeroTiles)).toBe(L0X0Y1);
    expect(L0X1Y1.findTileToEast(levelZeroTiles)).toBe(L0X2Y1);
    expect(L0X1Y1.findTileToNorth(levelZeroTiles)).toBe(L0X1Y0);
    expect(L0X1Y1.findTileToSouth(levelZeroTiles)).toBe(L0X1Y2);

    expect(L0X2Y1.findTileToWest(levelZeroTiles)).toBe(L0X1Y1);
    expect(L0X2Y1.findTileToEast(levelZeroTiles)).toBe(L0X0Y1);
    expect(L0X2Y1.findTileToNorth(levelZeroTiles)).toBe(L0X2Y0);
    expect(L0X2Y1.findTileToSouth(levelZeroTiles)).toBe(L0X2Y2);

    expect(L0X0Y2.findTileToWest(levelZeroTiles)).toBe(L0X2Y2);
    expect(L0X0Y2.findTileToEast(levelZeroTiles)).toBe(L0X1Y2);
    expect(L0X0Y2.findTileToNorth(levelZeroTiles)).toBe(L0X0Y1);
    expect(L0X0Y2.findTileToSouth(levelZeroTiles)).toBeUndefined();

    expect(L0X1Y2.findTileToWest(levelZeroTiles)).toBe(L0X0Y2);
    expect(L0X1Y2.findTileToEast(levelZeroTiles)).toBe(L0X2Y2);
    expect(L0X1Y2.findTileToNorth(levelZeroTiles)).toBe(L0X1Y1);
    expect(L0X1Y2.findTileToSouth(levelZeroTiles)).toBeUndefined();

    expect(L0X2Y2.findTileToWest(levelZeroTiles)).toBe(L0X1Y2);
    expect(L0X2Y2.findTileToEast(levelZeroTiles)).toBe(L0X0Y2);
    expect(L0X2Y2.findTileToNorth(levelZeroTiles)).toBe(L0X2Y1);
    expect(L0X2Y2.findTileToSouth(levelZeroTiles)).toBeUndefined();
  });

  it("can get tiles around a tile when they share a common parent", function () {
    var tilingScheme = new GeographicTilingScheme({
      numberOfLevelZeroTilesX: 2,
      numberOfLevelZeroTilesY: 1,
    });

    var levelZeroTiles = QuadtreeTile.createLevelZeroTiles(tilingScheme);
    var parent = levelZeroTiles[1];
    var sw = parent.southwestChild;
    var se = parent.southeastChild;
    var nw = parent.northwestChild;
    var ne = parent.northeastChild;

    expect(sw.findTileToEast(levelZeroTiles)).toBe(se);
    expect(sw.findTileToNorth(levelZeroTiles)).toBe(nw);
    expect(se.findTileToWest(levelZeroTiles)).toBe(sw);
    expect(se.findTileToNorth(levelZeroTiles)).toBe(ne);
    expect(nw.findTileToEast(levelZeroTiles)).toBe(ne);
    expect(nw.findTileToSouth(levelZeroTiles)).toBe(sw);
    expect(ne.findTileToWest(levelZeroTiles)).toBe(nw);
    expect(ne.findTileToSouth(levelZeroTiles)).toBe(se);
  });

  it("can get tiles around a tile when they do not share a common parent", function () {
    var tilingScheme = new GeographicTilingScheme({
      numberOfLevelZeroTilesX: 2,
      numberOfLevelZeroTilesY: 2,
    });

    var levelZeroTiles = QuadtreeTile.createLevelZeroTiles(tilingScheme);

    var northwest = levelZeroTiles[0];
    var nwse = northwest.southeastChild;
    var nwne = northwest.northeastChild;
    var nwsw = northwest.southwestChild;

    var northeast = levelZeroTiles[1];
    var nesw = northeast.southwestChild;
    var nenw = northeast.northwestChild;
    var nese = northeast.southeastChild;

    var southwest = levelZeroTiles[2];
    var swne = southwest.northeastChild;
    var swnw = southwest.northwestChild;
    var swse = southwest.southeastChild;

    var southeast = levelZeroTiles[3];
    var senw = southeast.northwestChild;
    var sene = southeast.northeastChild;
    var sesw = southeast.southwestChild;

    expect(nwse.findTileToEast(levelZeroTiles)).toBe(nesw);
    expect(nwse.findTileToSouth(levelZeroTiles)).toBe(swne);
    expect(nwne.findTileToEast(levelZeroTiles)).toBe(nenw);
    expect(nwsw.findTileToSouth(levelZeroTiles)).toBe(swnw);

    expect(nesw.findTileToWest(levelZeroTiles)).toBe(nwse);
    expect(nesw.findTileToSouth(levelZeroTiles)).toBe(senw);
    expect(nenw.findTileToWest(levelZeroTiles)).toBe(nwne);
    expect(nese.findTileToSouth(levelZeroTiles)).toBe(sene);

    expect(swne.findTileToEast(levelZeroTiles)).toBe(senw);
    expect(swne.findTileToNorth(levelZeroTiles)).toBe(nwse);
    expect(swnw.findTileToNorth(levelZeroTiles)).toBe(nwsw);
    expect(swse.findTileToEast(levelZeroTiles)).toBe(sesw);

    expect(senw.findTileToWest(levelZeroTiles)).toBe(swne);
    expect(senw.findTileToNorth(levelZeroTiles)).toBe(nesw);
    expect(sene.findTileToNorth(levelZeroTiles)).toBe(nese);
    expect(sesw.findTileToWest(levelZeroTiles)).toBe(swse);
  });

  it("can get adjacent tiles wrapping around the anti-meridian", function () {
    var tilingScheme = new GeographicTilingScheme({
      numberOfLevelZeroTilesX: 2,
      numberOfLevelZeroTilesY: 1,
    });

    var levelZeroTiles = QuadtreeTile.createLevelZeroTiles(tilingScheme);

    var west = levelZeroTiles[0];
    var wsw = west.southwestChild;
    var wnw = west.northwestChild;

    var east = levelZeroTiles[1];
    var ene = east.northeastChild;
    var ese = east.southeastChild;

    expect(wsw.findTileToWest(levelZeroTiles)).toBe(ese);
    expect(wnw.findTileToWest(levelZeroTiles)).toBe(ene);

    expect(ene.findTileToEast(levelZeroTiles)).toBe(wnw);
    expect(ese.findTileToEast(levelZeroTiles)).toBe(wsw);
  });

  it("returns undefined when asked for adjacent tiles north of the north pole or south of the south pole", function () {
    var tilingScheme = new GeographicTilingScheme({
      numberOfLevelZeroTilesX: 2,
      numberOfLevelZeroTilesY: 1,
    });

    var levelZeroTiles = QuadtreeTile.createLevelZeroTiles(tilingScheme);

    var west = levelZeroTiles[0];
    var wnw = west.northwestChild;
    var wsw = west.southwestChild;

    expect(wnw.findTileToNorth(levelZeroTiles)).toBeUndefined();
    expect(wsw.findTileToSouth(levelZeroTiles)).toBeUndefined();
  });

  describe("createLevelZeroTiles", function () {
    var tilingScheme1x1;
    var tilingScheme2x2;
    var tilingScheme2x1;
    var tilingScheme1x2;

    beforeEach(function () {
      tilingScheme1x1 = new GeographicTilingScheme({
        numberOfLevelZeroTilesX: 1,
        numberOfLevelZeroTilesY: 1,
      });
      tilingScheme2x2 = new GeographicTilingScheme({
        numberOfLevelZeroTilesX: 2,
        numberOfLevelZeroTilesY: 2,
      });
      tilingScheme2x1 = new GeographicTilingScheme({
        numberOfLevelZeroTilesX: 2,
        numberOfLevelZeroTilesY: 1,
      });
      tilingScheme1x2 = new GeographicTilingScheme({
        numberOfLevelZeroTilesX: 1,
        numberOfLevelZeroTilesY: 2,
      });
    });

    it("requires tilingScheme", function () {
      expect(function () {
        return QuadtreeTile.createLevelZeroTiles(undefined);
      }).toThrowDeveloperError();
    });

    it("creates expected number of tiles", function () {
      var tiles = QuadtreeTile.createLevelZeroTiles(tilingScheme1x1);
      expect(tiles.length).toBe(1);

      tiles = QuadtreeTile.createLevelZeroTiles(tilingScheme2x2);
      expect(tiles.length).toBe(4);

      tiles = QuadtreeTile.createLevelZeroTiles(tilingScheme2x1);
      expect(tiles.length).toBe(2);

      tiles = QuadtreeTile.createLevelZeroTiles(tilingScheme1x2);
      expect(tiles.length).toBe(2);
    });

    it("created tiles are associated with specified tiling scheme", function () {
      var tiles = QuadtreeTile.createLevelZeroTiles(tilingScheme2x2);
      for (var i = 0; i < tiles.length; ++i) {
        expect(tiles[i].tilingScheme).toBe(tilingScheme2x2);
      }
    });

    it("created tiles are ordered from the northwest and proceeding east and then south", function () {
      var tiles = QuadtreeTile.createLevelZeroTiles(tilingScheme2x2);
      var northwest = tiles[0];
      var northeast = tiles[1];
      var southwest = tiles[2];
      var southeast = tiles[3];

      expect(northeast.rectangle.west).toBeGreaterThan(
        northwest.rectangle.west
      );
      expect(southeast.rectangle.west).toBeGreaterThan(
        southwest.rectangle.west
      );
      expect(northeast.rectangle.south).toBeGreaterThan(
        southeast.rectangle.south
      );
      expect(northwest.rectangle.south).toBeGreaterThan(
        southwest.rectangle.south
      );
    });
  });
});