import { Cartesian3 } from "../../Source/Cesium.js";
import { Cartographic } from "../../Source/Cesium.js";
import { Color } from "../../Source/Cesium.js";
import { ColorGeometryInstanceAttribute } from "../../Source/Cesium.js";
import { destroyObject } from "../../Source/Cesium.js";
import { Ellipsoid } from "../../Source/Cesium.js";
import { GeometryInstance } from "../../Source/Cesium.js";
import { HeadingPitchRange } from "../../Source/Cesium.js";
import { Math as CesiumMath } from "../../Source/Cesium.js";
import { Matrix4 } from "../../Source/Cesium.js";
import { Rectangle } from "../../Source/Cesium.js";
import { RectangleGeometry } from "../../Source/Cesium.js";
import { Resource } from "../../Source/Cesium.js";
import { Pass } from "../../Source/Cesium.js";
import { RenderState } from "../../Source/Cesium.js";
import { ClassificationModel } from "../../Source/Cesium.js";
import { ClassificationType } from "../../Source/Cesium.js";
import { PerInstanceColorAppearance } from "../../Source/Cesium.js";
import { Primitive } from "../../Source/Cesium.js";
import { StencilConstants } from "../../Source/Cesium.js";
import createScene from "../createScene.js";
import pollToPromise from "../pollToPromise.js";
import { addDefaults } from "../../Source/Cesium.js";
import { parseGlb } from "../../Source/Cesium.js";
import { updateVersion } from "../../Source/Cesium.js";

describe(
  "Scene/ClassificationModel",
  function () {
    var scene;
    var modelMatrix;
    var centerLongitude = -1.31968;
    var centerLatitude = 0.698874;

    var batchedModel = "./Data/Models/Classification/batched.glb";
    var quantizedModel = "./Data/Models/Classification/batchedQuantization.glb";

    var globePrimitive;
    var tilesetPrimitive;
    var reusableGlobePrimitive;
    var reusableTilesetPrimitive;

    function setCamera(longitude, latitude) {
      // One feature is located at the center, point the camera there
      var center = Cartesian3.fromRadians(longitude, latitude);
      scene.camera.lookAt(center, new HeadingPitchRange(0.0, -1.57, 15.0));
    }

    function createPrimitive(rectangle, pass) {
      var renderState;
      if (pass === Pass.CESIUM_3D_TILE) {
        renderState = RenderState.fromCache({
          stencilTest: StencilConstants.setCesium3DTileBit(),
          stencilMask: StencilConstants.CESIUM_3D_TILE_MASK,
          depthTest: {
            enabled: true,
          },
        });
      }
      var depthColorAttribute = ColorGeometryInstanceAttribute.fromColor(
        new Color(0.0, 0.0, 0.0, 1.0)
      );
      return new Primitive({
        geometryInstances: new GeometryInstance({
          geometry: new RectangleGeometry({
            ellipsoid: Ellipsoid.WGS84,
            rectangle: rectangle,
          }),
          id: "depth rectangle",
          attributes: {
            color: depthColorAttribute,
          },
        }),
        appearance: new PerInstanceColorAppearance({
          translucent: false,
          flat: true,
          renderState: renderState,
        }),
        asynchronous: false,
      });
    }

    function MockPrimitive(primitive, pass) {
      this._primitive = primitive;
      this._pass = pass;
      this.show = true;
    }

    MockPrimitive.prototype.update = function (frameState) {
      if (!this.show) {
        return;
      }

      var commandList = frameState.commandList;
      var startLength = commandList.length;
      this._primitive.update(frameState);

      for (var i = startLength; i < commandList.length; ++i) {
        var command = commandList[i];
        command.pass = this._pass;
      }
    };

    MockPrimitive.prototype.isDestroyed = function () {
      return false;
    };

    MockPrimitive.prototype.destroy = function () {
      return destroyObject(this);
    };

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

      var translation = Ellipsoid.WGS84.geodeticSurfaceNormalCartographic(
        new Cartographic(centerLongitude, centerLatitude)
      );
      Cartesian3.multiplyByScalar(translation, -5.0, translation);
      modelMatrix = Matrix4.fromTranslation(translation);

      var offset = CesiumMath.toRadians(0.01);
      var rectangle = new Rectangle(
        centerLongitude - offset,
        centerLatitude - offset,
        centerLongitude + offset,
        centerLatitude + offset
      );
      reusableGlobePrimitive = createPrimitive(rectangle, Pass.GLOBE);
      reusableTilesetPrimitive = createPrimitive(
        rectangle,
        Pass.CESIUM_3D_TILE
      );
    });

    afterAll(function () {
      reusableGlobePrimitive.destroy();
      reusableTilesetPrimitive.destroy();
      scene.destroyForSpecs();
    });

    beforeEach(function () {
      setCamera(centerLongitude, centerLatitude);

      // wrap rectangle primitive so it gets executed during the globe pass and 3D Tiles pass to lay down depth
      globePrimitive = new MockPrimitive(reusableGlobePrimitive, Pass.GLOBE);
      tilesetPrimitive = new MockPrimitive(
        reusableTilesetPrimitive,
        Pass.CESIUM_3D_TILE
      );

      scene.primitives.add(globePrimitive);
      scene.primitives.add(tilesetPrimitive);
    });

    afterEach(function () {
      scene.primitives.removeAll();
      globePrimitive =
        globePrimitive &&
        !globePrimitive.isDestroyed() &&
        globePrimitive.destroy();
      tilesetPrimitive =
        tilesetPrimitive &&
        !tilesetPrimitive.isDestroyed() &&
        tilesetPrimitive.destroy();
    });

    function expectRender(scene, model) {
      model.show = false;
      expect(scene).toRender([0, 0, 0, 255]);
      model.show = true;
      expect(scene).toRenderAndCall(function (rgba) {
        expect(rgba).not.toEqual([0, 0, 0, 255]);
      });
    }

    function expectRenderBlank(scene, model) {
      model.show = false;
      expect(scene).toRender([0, 0, 0, 255]);
      model.show = true;
      expect(scene).toRender([0, 0, 0, 255]);
    }

    function loadGltf(model) {
      return Resource.fetchArrayBuffer(model).then(function (arrayBuffer) {
        var gltf = new Uint8Array(arrayBuffer);
        gltf = parseGlb(gltf);
        updateVersion(gltf);
        addDefaults(gltf);
        return gltf;
      });
    }

    function loadClassificationModel(url, classificationType) {
      return Resource.fetchArrayBuffer(url).then(function (arrayBuffer) {
        var model = scene.primitives.add(
          new ClassificationModel({
            gltf: arrayBuffer,
            classificationType: classificationType,
            modelMatrix: modelMatrix,
          })
        );

        var ready = false;
        model.readyPromise.then(function () {
          ready = true;
        });

        return pollToPromise(function () {
          scene.renderForSpecs();
          return ready;
        }).then(function () {
          return model;
        });
      });
    }

    it("classifies 3D Tiles", function () {
      return loadClassificationModel(
        batchedModel,
        ClassificationType.CESIUM_3D_TILE
      ).then(function (model) {
        globePrimitive.show = false;
        tilesetPrimitive.show = true;
        expectRender(scene, model);
        globePrimitive.show = true;
        tilesetPrimitive.show = false;
        expectRenderBlank(scene, model);
        globePrimitive.show = true;
        tilesetPrimitive.show = true;
      });
    });

    it("classifies globe", function () {
      return loadClassificationModel(
        batchedModel,
        ClassificationType.TERRAIN
      ).then(function (model) {
        globePrimitive.show = false;
        tilesetPrimitive.show = true;
        expectRenderBlank(scene, model);
        globePrimitive.show = true;
        tilesetPrimitive.show = false;
        expectRender(scene, model);
        globePrimitive.show = true;
        tilesetPrimitive.show = true;
      });
    });

    it("classifies both 3D Tiles and globe", function () {
      return loadClassificationModel(
        batchedModel,
        ClassificationType.BOTH
      ).then(function (model) {
        globePrimitive.show = false;
        tilesetPrimitive.show = true;
        expectRender(scene, model);
        globePrimitive.show = true;
        tilesetPrimitive.show = false;
        expectRender(scene, model);
        globePrimitive.show = true;
        tilesetPrimitive.show = true;
      });
    });

    it("renders batched model", function () {
      return loadClassificationModel(
        batchedModel,
        ClassificationType.BOTH
      ).then(function (model) {
        expectRender(scene, model);
      });
    });

    it("renders batched model with quantization", function () {
      return loadClassificationModel(
        quantizedModel,
        ClassificationType.BOTH
      ).then(function (model) {
        expectRender(scene, model);
      });
    });

    it("throws with invalid number of nodes", function () {
      return loadGltf(batchedModel).then(function (gltf) {
        gltf.nodes.push({});
        expect(function () {
          return new ClassificationModel({
            gltf: gltf,
          });
        }).toThrowRuntimeError();
      });
    });

    it("throws with invalid number of meshes", function () {
      return loadGltf(batchedModel).then(function (gltf) {
        gltf.meshes.push({});
        expect(function () {
          return new ClassificationModel({
            gltf: gltf,
          });
        }).toThrowRuntimeError();
      });
    });

    it("throws with invalid number of primitives", function () {
      return loadGltf(batchedModel).then(function (gltf) {
        gltf.meshes[0].primitives.push({});
        expect(function () {
          return new ClassificationModel({
            gltf: gltf,
          });
        }).toThrowRuntimeError();
      });
    });

    it("throws with position semantic", function () {
      return loadGltf(batchedModel).then(function (gltf) {
        gltf.meshes[0].primitives[0].attributes.POSITION = undefined;
        expect(function () {
          return new ClassificationModel({
            gltf: gltf,
          });
        }).toThrowRuntimeError();
      });
    });

    it("throws with batch id semantic", function () {
      return loadGltf(batchedModel).then(function (gltf) {
        gltf.meshes[0].primitives[0].attributes._BATCHID = undefined;
        expect(function () {
          return new ClassificationModel({
            gltf: gltf,
          });
        }).toThrowRuntimeError();
      });
    });
  },
  "WebGL"
);