import {
  Axis,
  Cesium3DTileStyle,
  Color,
  CustomShader,
  CustomShaderPipelineStage,
  Matrix4,
  ModelColorPipelineStage,
  ModelExperimentalSceneGraph,
  Pass,
  ResourceCache,
} from "../../../Source/Cesium.js";
import createScene from "../../createScene.js";
import loadAndZoomToModelExperimental from "./loadAndZoomToModelExperimental.js";

describe(
  "Scene/ModelExperimental/ModelExperimentalSceneGraph",
  function () {
    var parentGltfUrl = "./Data/Cesium3DTiles/GltfContent/glTF/parent.gltf";
    var vertexColorGltfUrl =
      "./Data/Models/PBR/VertexColorTest/VertexColorTest.gltf";
    var buildingsMetadata =
      "./Data/Models/GltfLoader/BuildingsMetadata/glTF/buildings-metadata.gltf";

    var scene;

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

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

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

    it("creates runtime nodes and runtime primitives from a model", function () {
      return loadAndZoomToModelExperimental(
        { gltf: vertexColorGltfUrl },
        scene
      ).then(function (model) {
        var sceneGraph = model._sceneGraph;
        var modelComponents = sceneGraph._modelComponents;

        expect(sceneGraph).toBeDefined();

        var runtimeNodes = sceneGraph._runtimeNodes;
        expect(runtimeNodes.length).toEqual(modelComponents.nodes.length);

        expect(runtimeNodes[0].runtimePrimitives.length).toEqual(1);
        expect(runtimeNodes[1].runtimePrimitives.length).toEqual(1);
      });
    });

    it("builds draw commands for all opaque styled features", function () {
      return loadAndZoomToModelExperimental(
        {
          gltf: buildingsMetadata,
        },
        scene
      ).then(function (model) {
        model.style = new Cesium3DTileStyle({
          color: {
            conditions: [["${height} > 1", "color('red')"]],
          },
        });
        var frameState = scene.frameState;
        var sceneGraph = model._sceneGraph;
        // Reset the draw commands so we can inspect the draw command generation.
        model._drawCommandsBuilt = false;
        sceneGraph._drawCommands = [];
        frameState.commandList = [];
        scene.renderForSpecs();
        expect(sceneGraph._drawCommands.length).toEqual(1);
        expect(frameState.commandList.length).toEqual(1);
        expect(sceneGraph._drawCommands[0].pass).toEqual(Pass.OPAQUE);
      });
    });

    it("builds draw commands for all translucent styled features", function () {
      return loadAndZoomToModelExperimental(
        {
          gltf: buildingsMetadata,
        },
        scene
      ).then(function (model) {
        model.style = new Cesium3DTileStyle({
          color: {
            conditions: [["${height} > 1", "color('red', 0.1)"]],
          },
        });
        var frameState = scene.frameState;
        var sceneGraph = model._sceneGraph;
        // Reset the draw commands so we can inspect the draw command generation.
        model._drawCommandsBuilt = false;
        sceneGraph._drawCommands = [];
        frameState.commandList = [];
        scene.renderForSpecs();
        expect(sceneGraph._drawCommands.length).toEqual(1);
        expect(frameState.commandList.length).toEqual(1);
        expect(sceneGraph._drawCommands[0].pass).toEqual(Pass.TRANSLUCENT);
      });
    });

    it("builds draw commands for both opaque and translucent styled features", function () {
      return loadAndZoomToModelExperimental(
        {
          gltf: buildingsMetadata,
        },
        scene
      ).then(function (model) {
        model.style = new Cesium3DTileStyle({
          color: {
            conditions: [
              ["${height} > 80", "color('red', 0.1)"],
              ["true", "color('blue')"],
            ],
          },
        });
        var frameState = scene.frameState;
        var sceneGraph = model._sceneGraph;
        // Reset the draw commands so we can inspect the draw command generation.
        model._drawCommandsBuilt = false;
        sceneGraph._drawCommands = [];
        frameState.commandList = [];
        scene.renderForSpecs();
        expect(sceneGraph._drawCommands.length).toEqual(2);
        expect(frameState.commandList.length).toEqual(2);
        expect(sceneGraph._drawCommands[0].pass).toEqual(Pass.OPAQUE);
        expect(sceneGraph._drawCommands[1].pass).toEqual(Pass.TRANSLUCENT);
      });
    });

    it("builds draw commands for each primitive", function () {
      spyOn(
        ModelExperimentalSceneGraph.prototype,
        "buildDrawCommands"
      ).and.callThrough();
      return loadAndZoomToModelExperimental(
        { gltf: parentGltfUrl },
        scene
      ).then(function (model) {
        var sceneGraph = model._sceneGraph;
        var runtimeNodes = sceneGraph._runtimeNodes;

        var primitivesCount = 0;
        for (var i = 0; i < runtimeNodes.length; i++) {
          primitivesCount += runtimeNodes[i].runtimePrimitives.length;
        }

        var frameState = scene.frameState;
        frameState.commandList = [];
        scene.renderForSpecs();
        expect(
          ModelExperimentalSceneGraph.prototype.buildDrawCommands
        ).toHaveBeenCalled();
        expect(frameState.commandList.length).toEqual(primitivesCount);

        expect(model._drawCommandsBuilt).toEqual(true);
        expect(sceneGraph._drawCommands.length).toEqual(primitivesCount);

        // Reset the draw command list to see if they're re-built.
        model._drawCommandsBuilt = false;
        sceneGraph._drawCommands = [];
        frameState.commandList = [];
        scene.renderForSpecs();
        expect(
          ModelExperimentalSceneGraph.prototype.buildDrawCommands
        ).toHaveBeenCalled();
        expect(frameState.commandList.length).toEqual(primitivesCount);
      });
    });

    it("traverses scene graph correctly", function () {
      return loadAndZoomToModelExperimental(
        { gltf: parentGltfUrl },
        scene
      ).then(function (model) {
        var sceneGraph = model._sceneGraph;
        var modelComponents = sceneGraph._modelComponents;
        var runtimeNodes = sceneGraph._runtimeNodes;

        expect(runtimeNodes[1].node).toEqual(modelComponents.nodes[0]);
        expect(runtimeNodes[0].node).toEqual(modelComponents.nodes[1]);
      });
    });

    it("propagates node transforms correctly", function () {
      return loadAndZoomToModelExperimental(
        {
          gltf: parentGltfUrl,
          upAxis: Axis.Z,
          forwardAxis: Axis.X,
        },
        scene
      ).then(function (model) {
        var sceneGraph = model._sceneGraph;
        var modelComponents = sceneGraph._modelComponents;
        var scene = modelComponents.scene;
        var runtimeNodes = sceneGraph._runtimeNodes;

        expect(scene.upAxis).toEqual(Axis.Z);
        expect(scene.forwardAxis).toEqual(Axis.X);

        expect(runtimeNodes[1].modelMatrix).toEqual(
          modelComponents.nodes[0].matrix
        );
        expect(runtimeNodes[0].modelMatrix).toEqual(
          Matrix4.multiplyByTranslation(
            runtimeNodes[1].modelMatrix,
            modelComponents.nodes[1].translation,
            new Matrix4()
          )
        );
      });
    });

    it("adds ModelColorPipelineStage when color is set on the model", function () {
      spyOn(ModelColorPipelineStage, "process");
      return loadAndZoomToModelExperimental(
        {
          color: Color.RED,
          gltf: parentGltfUrl,
        },
        scene
      ).then(function () {
        expect(ModelColorPipelineStage.process).toHaveBeenCalled();
      });
    });

    it("adds CustomShaderPipelineStage when customShader is set on the model", function () {
      spyOn(CustomShaderPipelineStage, "process");
      return loadAndZoomToModelExperimental(
        {
          gltf: buildingsMetadata,
        },
        scene
      ).then(function (model) {
        model.customShader = new CustomShader();
        model.update(scene.frameState);
        expect(CustomShaderPipelineStage.process).toHaveBeenCalled();
      });
    });

    it("throws for undefined options.model", function () {
      expect(function () {
        return new ModelExperimentalSceneGraph({
          model: undefined,
          modelComponents: {},
        });
      }).toThrowDeveloperError();
    });

    it("throws for undefined options.modelComponents", function () {
      expect(function () {
        return new ModelExperimentalSceneGraph({
          model: {},
          modelComponents: undefined,
        });
      }).toThrowDeveloperError();
    });
  },
  "WebGL"
);