import {
  combine,
  GltfLoader,
  FeatureIdPipelineStage,
  ShaderBuilder,
  ShaderDestination,
  Resource,
  ResourceCache,
  _shadersFeatureStageCommon,
  _shadersFeatureStageFS,
  _shadersFeatureStageVS,
} from "../../../Source/Cesium.js";
import createScene from "../../createScene.js";
import ShaderBuilderTester from "../../ShaderBuilderTester.js";
import waitForLoaderProcess from "../../waitForLoaderProcess.js";

describe("Scene/ModelExperimental/FeatureIdPipelineStage", function () {
  var buildingsMetadata =
    "./Data/Models/GltfLoader/BuildingsMetadata/glTF/buildings-metadata.gltf";
  var microcosm = "./Data/Models/GltfLoader/Microcosm/glTF/microcosm.gltf";
  var boxInstanced =
    "./Data/Models/GltfLoader/BoxInstanced/glTF/box-instanced.gltf";

  var scene;
  var gltfLoaders = [];

  var defaultShaderBuilder;

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

  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 createDefaultShaderBuilder() {
    var shaderBuilder = new ShaderBuilder();
    shaderBuilder.addStruct(
      FeatureIdPipelineStage.STRUCT_ID_FEATURE,
      FeatureIdPipelineStage.STRUCT_NAME_FEATURE,
      ShaderDestination.BOTH
    );
    return shaderBuilder;
  }

  function verifyFeatureStruct(shaderBuilder) {
    ShaderBuilderTester.expectHasVertexStruct(
      shaderBuilder,
      FeatureIdPipelineStage.STRUCT_ID_FEATURE,
      FeatureIdPipelineStage.STRUCT_NAME_FEATURE,
      ["    int id;", "    vec2 st;", "    vec4 color;"]
    );
    ShaderBuilderTester.expectHasFragmentStruct(
      shaderBuilder,
      FeatureIdPipelineStage.STRUCT_ID_FEATURE,
      FeatureIdPipelineStage.STRUCT_NAME_FEATURE,
      ["    int id;", "    vec2 st;", "    vec4 color;"]
    );
  }

  function verifyFeatureStructFunctions(shaderBuilder) {
    ShaderBuilderTester.expectHasVertexFunction(
      shaderBuilder,
      FeatureIdPipelineStage.FUNCTION_ID_FEATURE_VARYINGS_VS,
      FeatureIdPipelineStage.FUNCTION_SIGNATURE_UPDATE_FEATURE,
      [
        "    v_activeFeatureId = float(feature.id);",
        "    v_activeFeatureSt = feature.st;",
        "    v_activeFeatureColor = feature.color;",
      ]
    );
    ShaderBuilderTester.expectHasFragmentFunction(
      shaderBuilder,
      FeatureIdPipelineStage.FUNCTION_ID_FEATURE_VARYINGS_FS,
      FeatureIdPipelineStage.FUNCTION_SIGNATURE_UPDATE_FEATURE,
      [
        "    feature.id = int(v_activeFeatureId);",
        "    feature.st = v_activeFeatureSt;",
        "    feature.color = v_activeFeatureColor;",
      ]
    );
  }

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

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

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

    return waitForLoaderProcess(gltfLoader, scene);
  }

  function expectUniformMap(uniformMap, expected) {
    for (var key in expected) {
      if (expected.hasOwnProperty(key)) {
        var expectedValue = expected[key];
        var uniformFunction = uniformMap[key];
        expect(uniformFunction).toBeDefined();
        expect(uniformFunction()).toEqual(expectedValue);
      }
    }
  }

  it("processes primitive feature IDs from vertex attribute", function () {
    var renderResources = {
      shaderBuilder: defaultShaderBuilder.clone(),
      model: {
        featureIdAttributeIndex: 0,
      },
      runtimeNode: { node: {} },
      hasFeatureIds: false,
      featureTableId: undefined,
    };

    return loadGltf(buildingsMetadata).then(function (gltfLoader) {
      var components = gltfLoader.components;
      var primitive = components.nodes[1].primitives[0];

      var frameState = scene.frameState;
      var context = frameState.context;
      // Reset pick objects.
      context._pickObjects = [];

      FeatureIdPipelineStage.process(renderResources, primitive, frameState);

      expect(renderResources.hasFeatureIds).toBe(true);

      var shaderBuilder = renderResources.shaderBuilder;

      ShaderBuilderTester.expectHasVertexDefines(shaderBuilder, [
        "HAS_FEATURES",
        "FEATURE_ID_ATTRIBUTE a_featureId_0",
      ]);

      ShaderBuilderTester.expectHasFragmentDefines(shaderBuilder, [
        "HAS_FEATURES",
      ]);
      ShaderBuilderTester.expectHasVaryings(shaderBuilder, [
        "varying float v_activeFeatureId;",
        "varying vec2 v_activeFeatureSt;",
        "varying vec4 v_activeFeatureColor;",
      ]);

      verifyFeatureStruct(shaderBuilder);
      verifyFeatureStructFunctions(shaderBuilder);

      ShaderBuilderTester.expectVertexLinesEqual(shaderBuilder, [
        _shadersFeatureStageCommon,
        _shadersFeatureStageVS,
      ]);

      ShaderBuilderTester.expectFragmentLinesEqual(shaderBuilder, [
        _shadersFeatureStageCommon,
        _shadersFeatureStageFS,
      ]);
    });
  });

  it("processes primitive implicit feature IDs", function () {
    var renderResources = {
      shaderBuilder: defaultShaderBuilder.clone(),
      model: {
        featureIdAttributeIndex: 1,
        _resources: [],
      },
      attributeIndex: 4,
      attributes: [],
      runtimeNode: { node: {} },
      hasFeatureIds: false,
      propertyTableId: undefined,
      featureIdVertexAttributeSetIndex: 1,
    };

    return loadGltf(buildingsMetadata).then(function (gltfLoader) {
      var components = gltfLoader.components;
      var primitive = components.nodes[1].primitives[0];

      var frameState = scene.frameState;
      var context = frameState.context;
      // Reset pick objects.
      context._pickObjects = [];

      FeatureIdPipelineStage.process(renderResources, primitive, frameState);

      expect(renderResources.hasFeatureIds).toBe(true);

      var shaderBuilder = renderResources.shaderBuilder;

      ShaderBuilderTester.expectHasVertexDefines(shaderBuilder, [
        "HAS_FEATURES",
        "FEATURE_ID_ATTRIBUTE a_featureId_1",
      ]);

      ShaderBuilderTester.expectHasFragmentDefines(shaderBuilder, [
        "HAS_FEATURES",
      ]);

      ShaderBuilderTester.expectHasAttributes(shaderBuilder, undefined, [
        "attribute float a_featureId_1;",
      ]);
      ShaderBuilderTester.expectHasVaryings(shaderBuilder, [
        "varying float v_activeFeatureId;",
        "varying vec2 v_activeFeatureSt;",
        "varying vec4 v_activeFeatureColor;",
      ]);

      ShaderBuilderTester.expectVertexLinesEqual(shaderBuilder, [
        _shadersFeatureStageCommon,
        _shadersFeatureStageVS,
      ]);

      ShaderBuilderTester.expectFragmentLinesEqual(shaderBuilder, [
        _shadersFeatureStageCommon,
        _shadersFeatureStageFS,
      ]);

      verifyFeatureStruct(shaderBuilder);
      verifyFeatureStructFunctions(shaderBuilder);

      expect(renderResources.featureIdVertexAttributeSetIndex).toEqual(2);

      var vertexBuffer = renderResources.model._resources[0];
      expect(vertexBuffer.vertexArrayDestroyable).toBe(false);

      var vertexAttribute = renderResources.attributes[0];
      expect(vertexAttribute.instanceDivisor).toEqual(0);
      expect(vertexAttribute.vertexBuffer).toBe(vertexBuffer);
    });
  });

  it("processes primitive implicit feature ID constant only", function () {
    var renderResources = {
      shaderBuilder: defaultShaderBuilder.clone(),
      model: {
        featureIdAttributeIndex: 2,
        _resources: [],
      },
      attributeIndex: 4,
      attributes: [],
      runtimeNode: { node: {} },
      hasFeatureIds: false,
      propertyTableId: undefined,
      featureIdVertexAttributeSetIndex: 1,
    };

    return loadGltf(buildingsMetadata).then(function (gltfLoader) {
      var components = gltfLoader.components;
      var primitive = components.nodes[1].primitives[0];

      var frameState = scene.frameState;
      var context = frameState.context;
      // Reset pick objects.
      context._pickObjects = [];

      FeatureIdPipelineStage.process(renderResources, primitive, frameState);

      expect(renderResources.hasFeatureIds).toBe(true);

      var shaderBuilder = renderResources.shaderBuilder;

      ShaderBuilderTester.expectHasVertexDefines(shaderBuilder, [
        "HAS_FEATURES",
        "FEATURE_ID_ATTRIBUTE a_featureId_1",
      ]);

      ShaderBuilderTester.expectHasFragmentDefines(shaderBuilder, [
        "HAS_FEATURES",
      ]);

      ShaderBuilderTester.expectHasAttributes(shaderBuilder, undefined, [
        "attribute float a_featureId_1;",
      ]);
      ShaderBuilderTester.expectHasVaryings(shaderBuilder, [
        "varying float v_activeFeatureId;",
        "varying vec2 v_activeFeatureSt;",
        "varying vec4 v_activeFeatureColor;",
      ]);

      ShaderBuilderTester.expectVertexLinesEqual(shaderBuilder, [
        _shadersFeatureStageCommon,
        _shadersFeatureStageVS,
      ]);

      ShaderBuilderTester.expectFragmentLinesEqual(shaderBuilder, [
        _shadersFeatureStageCommon,
        _shadersFeatureStageFS,
      ]);

      verifyFeatureStruct(shaderBuilder);
      verifyFeatureStructFunctions(shaderBuilder);

      expect(renderResources.featureIdVertexAttributeSetIndex).toEqual(2);

      expect(renderResources.model._resources).toEqual([]);

      var vertexAttribute = renderResources.attributes[0];
      expect(vertexAttribute.instanceDivisor).toEqual(0);
      expect(vertexAttribute.buffer).not.toBeDefined();
      expect(vertexAttribute.value).toBe(3);
    });
  });

  it("processes instances feature IDs from vertex attribute", function () {
    var renderResources = {
      shaderBuilder: defaultShaderBuilder.clone(),
      model: {
        featureIdAttributeIndex: 1,
      },
      runtimeNode: {},
      hasFeatureIds: false,
      propertyTableId: undefined,
    };

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

      var frameState = scene.frameState;
      var context = frameState.context;
      // Reset pick objects.
      context._pickObjects = [];

      FeatureIdPipelineStage.process(renderResources, primitive, frameState);

      expect(renderResources.hasFeatureIds).toBe(true);

      var shaderBuilder = renderResources.shaderBuilder;

      ShaderBuilderTester.expectHasVertexDefines(shaderBuilder, [
        "HAS_FEATURES",
        "FEATURE_ID_ATTRIBUTE a_instanceFeatureId_0",
      ]);

      ShaderBuilderTester.expectHasFragmentDefines(shaderBuilder, [
        "HAS_FEATURES",
      ]);

      ShaderBuilderTester.expectHasVaryings(shaderBuilder, [
        "varying float v_activeFeatureId;",
        "varying vec2 v_activeFeatureSt;",
        "varying vec4 v_activeFeatureColor;",
      ]);

      verifyFeatureStruct(shaderBuilder);
      verifyFeatureStructFunctions(shaderBuilder);

      ShaderBuilderTester.expectVertexLinesEqual(shaderBuilder, [
        _shadersFeatureStageCommon,
        _shadersFeatureStageVS,
      ]);

      ShaderBuilderTester.expectFragmentLinesEqual(shaderBuilder, [
        _shadersFeatureStageCommon,
        _shadersFeatureStageFS,
      ]);
    });
  });

  it("processes instance implicit feature IDs", function () {
    var renderResources = {
      shaderBuilder: defaultShaderBuilder.clone(),
      model: {
        featureIdAttributeIndex: 0,
        _resources: [],
      },
      attributeIndex: 4,
      attributes: [],
      runtimeNode: { node: {} },
      hasFeatureIds: false,
      propertyTableId: undefined,
      featureIdVertexAttributeSetIndex: 1,
    };

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

      var frameState = scene.frameState;
      var context = frameState.context;
      // Reset pick objects.
      context._pickObjects = [];

      FeatureIdPipelineStage.process(renderResources, primitive, frameState);

      expect(renderResources.hasFeatureIds).toBe(true);

      var shaderBuilder = renderResources.shaderBuilder;

      ShaderBuilderTester.expectHasVertexDefines(shaderBuilder, [
        "HAS_FEATURES",
        "FEATURE_ID_ATTRIBUTE a_instanceFeatureId_1",
      ]);

      ShaderBuilderTester.expectHasFragmentDefines(shaderBuilder, [
        "HAS_FEATURES",
      ]);

      ShaderBuilderTester.expectHasAttributes(shaderBuilder, undefined, [
        "attribute float a_instanceFeatureId_1;",
      ]);
      ShaderBuilderTester.expectHasVaryings(shaderBuilder, [
        "varying float v_activeFeatureId;",
        "varying vec2 v_activeFeatureSt;",
        "varying vec4 v_activeFeatureColor;",
      ]);

      verifyFeatureStruct(shaderBuilder);
      verifyFeatureStructFunctions(shaderBuilder);

      ShaderBuilderTester.expectVertexLinesEqual(shaderBuilder, [
        _shadersFeatureStageCommon,
        _shadersFeatureStageVS,
      ]);

      ShaderBuilderTester.expectFragmentLinesEqual(shaderBuilder, [
        _shadersFeatureStageCommon,
        _shadersFeatureStageFS,
      ]);

      expect(renderResources.featureIdVertexAttributeSetIndex).toEqual(2);

      var vertexBuffer = renderResources.model._resources[0];
      expect(vertexBuffer.vertexArrayDestroyable).toBe(false);

      var vertexAttribute = renderResources.attributes[0];
      expect(vertexAttribute.instanceDivisor).toEqual(1);
      expect(vertexAttribute.vertexBuffer).toBe(vertexBuffer);
    });
  });

  it("processes feature IDs from texture", function () {
    var renderResources = {
      attributeIndex: 1,
      hasFeatureIds: false,
      shaderBuilder: defaultShaderBuilder.clone(),
      model: {
        featureIdTextureIndex: 0,
      },
      uniformMap: {},
    };

    return loadGltf(microcosm).then(function (gltfLoader) {
      var components = gltfLoader.components;
      var primitive = components.nodes[0].primitives[0];

      var frameState = scene.frameState;
      var context = frameState.context;
      // Reset pick objects.
      context._pickObjects = [];

      FeatureIdPipelineStage.process(renderResources, primitive, frameState);
      expect(renderResources.hasFeatureIds).toBe(true);

      var shaderBuilder = renderResources.shaderBuilder;
      ShaderBuilderTester.expectHasVertexDefines(shaderBuilder, [
        "HAS_FEATURES",
      ]);

      ShaderBuilderTester.expectHasFragmentDefines(shaderBuilder, [
        "HAS_FEATURES",
        "FEATURE_ID_TEXTURE u_featureIdTexture_0",
        "FEATURE_ID_TEXCOORD v_texCoord_0",
        "FEATURE_ID_CHANNEL r",
      ]);

      ShaderBuilderTester.expectHasFragmentUniforms(shaderBuilder, [
        "uniform sampler2D u_featureIdTexture_0;",
      ]);

      var expectedUniforms = {
        u_featureIdTexture_0:
          primitive.featureIdTextures[0].textureReader.texture,
      };

      expectUniformMap(renderResources.uniformMap, expectedUniforms);
    });
  });
});