import {
  Cartesian3,
  combine,
  GltfLoader,
  InstancingPipelineStage,
  Resource,
  ResourceCache,
  ShaderBuilder,
  Math as CesiumMath,
} from "../../../Source/Cesium.js";
import createScene from "../../createScene.js";
import waitForLoaderProcess from "../../waitForLoaderProcess.js";

describe("Scene/ModelExperimental/InstancingPipelineStage", function () {
  var boxInstanced =
    "./Data/Models/GltfLoader/BoxInstanced/glTF/box-instanced.gltf";
  var boxInstancedTranslation =
    "./Data/Models/GltfLoader/BoxInstancedTranslation/glTF/box-instanced-translation.gltf";
  var boxInstancedTranslationMinMax =
    "./Data/Models/GltfLoader/BoxInstancedTranslationWithMinMax/glTF/box-instanced-translation-min-max.gltf";

  var scene;
  var gltfLoaders = [];

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

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

  afterEach(function () {
    var gltfLoadersLength = gltfLoaders.length;
    for (var i = 0; i < gltfLoadersLength; ++i) {
      var gltfLoader = gltfLoaders[i];
      if (!gltfLoader.isDestroyed()) {
        gltfLoader.destroy();
      }
    }
    gltfLoaders.length = 0;
    ResourceCache.clearForSpecs();
  });

  function getOptions(gltfPath, options) {
    var resource = new Resource({
      url: gltfPath,
    });

    return combine(options, {
      gltfResource: resource,
      incrementallyLoadTexture: false,
    });
  }

  function loadGltf(gltfPath, options) {
    var gltfLoader = new GltfLoader(getOptions(gltfPath, options));
    gltfLoaders.push(gltfLoader);
    gltfLoader.load();

    return waitForLoaderProcess(gltfLoader, scene);
  }

  it("correctly computes instancing TRANSLATION min and max from typed arrays", function () {
    var renderResources = {
      attributeIndex: 1,
      attributes: [],
      instancingTranslationMax: undefined,
      instancingTranslationMin: undefined,
      shaderBuilder: new ShaderBuilder(),
      model: {
        _resources: [],
      },
    };

    return loadGltf(boxInstanced).then(function (gltfLoader) {
      var components = gltfLoader.components;
      var node = components.nodes[0];

      scene.renderForSpecs();
      InstancingPipelineStage.process(renderResources, node, scene.frameState);

      expect(renderResources.instancingTranslationMax).toEqual(
        new Cartesian3(2, 2, 0)
      );
      expect(renderResources.instancingTranslationMin).toEqual(
        new Cartesian3(-2, -2, 0)
      );
      expect(renderResources.attributes.length).toBe(4);
    });
  });

  it("sets instancing TRANSLATION min and max from attributes", function () {
    var renderResources = {
      attributeIndex: 1,
      attributes: [],
      instancingTranslationMax: undefined,
      instancingTranslationMin: undefined,
      shaderBuilder: new ShaderBuilder(),
      model: {
        _resources: [],
      },
    };

    return loadGltf(boxInstancedTranslationMinMax).then(function (gltfLoader) {
      var components = gltfLoader.components;
      var node = components.nodes[0];

      InstancingPipelineStage.process(renderResources, node);

      expect(renderResources.instancingTranslationMax).toEqual(
        new Cartesian3(2, 2, 0)
      );
      expect(renderResources.instancingTranslationMin).toEqual(
        new Cartesian3(-2, -2, 0)
      );
      expect(renderResources.attributes.length).toBe(1);
    });
  });

  it("creates instancing matrices vertex attributes when ROTATION is present", function () {
    var renderResources = {
      attributeIndex: 1,
      attributes: [],
      instancingTranslationMax: undefined,
      instancingTranslationMin: undefined,
      shaderBuilder: new ShaderBuilder(),
      model: {
        _resources: [],
      },
    };

    return loadGltf(boxInstanced).then(function (gltfLoader) {
      var components = gltfLoader.components;
      var node = components.nodes[0];

      scene.renderForSpecs();
      InstancingPipelineStage.process(renderResources, node, scene.frameState);

      expect(renderResources.instancingTranslationMax).toEqual(
        new Cartesian3(2, 2, 0)
      );
      expect(renderResources.instancingTranslationMin).toEqual(
        new Cartesian3(-2, -2, 0)
      );
      expect(renderResources.attributes.length).toBe(4);

      var attributeLines = renderResources.shaderBuilder._attributeLines;
      var vertexDefineLines =
        renderResources.shaderBuilder._vertexShaderParts.defineLines;
      var fragmentDefineLines =
        renderResources.shaderBuilder._fragmentShaderParts.defineLines;

      expect(vertexDefineLines[0]).toEqual("HAS_INSTANCING");
      expect(vertexDefineLines[0]).toEqual("HAS_INSTANCING");
      expect(vertexDefineLines[1]).toEqual("HAS_INSTANCE_MATRICES");
      expect(fragmentDefineLines[1]).toEqual("HAS_INSTANCE_MATRICES");
      expect(attributeLines[0]).toEqual(
        "attribute vec4 a_instancingTransformRow0;"
      );
      expect(attributeLines[1]).toEqual(
        "attribute vec4 a_instancingTransformRow1;"
      );
      expect(attributeLines[2]).toEqual(
        "attribute vec4 a_instancingTransformRow2;"
      );
    });
  });

  it("creates instance matrices vertex attributes when TRANSLATION min and max are not present", function () {
    var renderResources = {
      attributeIndex: 1,
      attributes: [],
      instancingTranslationMax: undefined,
      instancingTranslationMin: undefined,
      shaderBuilder: new ShaderBuilder(),
      model: {
        _resources: [],
      },
    };

    return loadGltf(boxInstancedTranslation).then(function (gltfLoader) {
      var components = gltfLoader.components;
      var node = components.nodes[0];

      scene.renderForSpecs();
      InstancingPipelineStage.process(renderResources, node, scene.frameState);

      expect(renderResources.instancingTranslationMax).toEqual(
        new Cartesian3(2, 2, 0)
      );
      expect(renderResources.instancingTranslationMin).toEqual(
        new Cartesian3(-2, -2, 0)
      );
      expect(renderResources.attributes.length).toBe(3);

      var attributeLines = renderResources.shaderBuilder._attributeLines;
      var vertexDefineLines =
        renderResources.shaderBuilder._vertexShaderParts.defineLines;
      var fragmentDefineLines =
        renderResources.shaderBuilder._fragmentShaderParts.defineLines;

      expect(vertexDefineLines[0]).toEqual("HAS_INSTANCING");
      expect(vertexDefineLines[0]).toEqual("HAS_INSTANCING");
      expect(vertexDefineLines[1]).toEqual("HAS_INSTANCE_MATRICES");
      expect(fragmentDefineLines[1]).toEqual("HAS_INSTANCE_MATRICES");

      expect(attributeLines[0]).toEqual(
        "attribute vec4 a_instancingTransformRow0;"
      );
      expect(attributeLines[1]).toEqual(
        "attribute vec4 a_instancingTransformRow1;"
      );
      expect(attributeLines[2]).toEqual(
        "attribute vec4 a_instancingTransformRow2;"
      );

      expect(renderResources.model._resources.length).toEqual(1);
    });
  });

  it("correctly creates transform matrices", function () {
    var renderResources = {
      attributeIndex: 1,
      attributes: [],
      instancingTranslationMax: undefined,
      instancingTranslationMin: undefined,
      shaderBuilder: new ShaderBuilder(),
      model: {
        _resources: [],
      },
    };

    return loadGltf(boxInstanced).then(function (gltfLoader) {
      var components = gltfLoader.components;
      var node = components.nodes[0];

      var expectedTransformsTypedArray = new Float32Array([
        0.5999999642372131,
        0,
        0,
        -2,
        0,
        0.4949747323989868,
        -0.7071067094802856,
        2,
        0,
        0.49497467279434204,
        0.7071067690849304,
        0,
        0.7071068286895752,
        4.174155421310388e-8,
        0.3535534143447876,
        -2,
        0.5,
        0.7071068286895752,
        -0.2500000298023224,
        -2,
        -0.5000000596046448,
        0.7071068286895752,
        0.25,
        0,
        0.375,
        -0.10000001639127731,
        0.3535534143447876,
        2,
        0.6401650905609131,
        0.029289301484823227,
        -0.2500000298023224,
        -2,
        0.10983504354953766,
        0.1707106977701187,
        0.25,
        0,
        0.4898979365825653,
        -0.3674234449863434,
        0.44999992847442627,
        2,
        0.5277916193008423,
        0.028420301154255867,
        -0.6749999523162842,
        2,
        0.3484765887260437,
        0.4734894633293152,
        0.3897113800048828,
        0,
      ]);
      var transformsTypedArray = InstancingPipelineStage._getInstanceTransformsTypedArray(
        node.instances,
        node.instances.attributes[0].count,
        renderResources
      );

      expect(transformsTypedArray.length).toEqual(
        expectedTransformsTypedArray.length
      );
      for (var i = 0; i < expectedTransformsTypedArray.length; i++) {
        expect(transformsTypedArray[i]).toEqualEpsilon(
          expectedTransformsTypedArray[i],
          CesiumMath.EPSILON10
        );
      }
    });
  });

  it("creates TRANSLATION vertex attributes", function () {
    var renderResources = {
      attributeIndex: 1,
      attributes: [],
      instancingTranslationMax: undefined,
      instancingTranslationMin: undefined,
      shaderBuilder: new ShaderBuilder(),
      model: {
        _resources: [],
      },
    };

    return loadGltf(boxInstancedTranslationMinMax).then(function (gltfLoader) {
      var components = gltfLoader.components;
      var node = components.nodes[0];

      scene.renderForSpecs();
      InstancingPipelineStage.process(renderResources, node, scene.frameState);

      expect(renderResources.instancingTranslationMax).toEqual(
        new Cartesian3(2, 2, 0)
      );
      expect(renderResources.instancingTranslationMin).toEqual(
        new Cartesian3(-2, -2, 0)
      );
      expect(renderResources.attributes.length).toBe(1);

      var attributeLines = renderResources.shaderBuilder._attributeLines;
      var vertexDefineLines =
        renderResources.shaderBuilder._vertexShaderParts.defineLines;
      var fragmentDefineLines =
        renderResources.shaderBuilder._fragmentShaderParts.defineLines;

      expect(vertexDefineLines[0]).toEqual("HAS_INSTANCING");
      expect(vertexDefineLines[0]).toEqual("HAS_INSTANCING");
      expect(vertexDefineLines[1]).toEqual("HAS_INSTANCE_TRANSLATION");
      expect(fragmentDefineLines[1]).toEqual("HAS_INSTANCE_TRANSLATION");

      expect(attributeLines[0]).toEqual(
        "attribute vec3 a_instanceTranslation;"
      );
    });
  });
});