import {
  combine,
  GltfLoader,
  PickingPipelineStage,
  ShaderBuilder,
  Resource,
  ResourceCache,
  defined,
} from "../../../Source/Cesium.js";
import createScene from "../../createScene.js";
import ShaderBuilderTester from "../../ShaderBuilderTester.js";
import waitForLoaderProcess from "../../waitForLoaderProcess.js";

describe("Scene/ModelExperimental/PickingPipelineStage", function () {
  var boxVertexColors =
    "./Data/Models/GltfLoader/BoxVertexColors/glTF/BoxVertexColors.gltf";
  var boxInstanced =
    "./Data/Models/GltfLoader/BoxInstanced/glTF/box-instanced.gltf";
  var microcosm = "./Data/Models/GltfLoader/Microcosm/glTF/microcosm.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);
  }

  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);
      }
    }
  }

  function verifyPickObject(pickObject, renderResources, instanceId) {
    var model = renderResources.model;
    var content = model.content;

    expect(pickObject).toBeDefined();
    if (defined(content)) {
      // 3D Tiles case
      expect(pickObject.primitive).toEqual(content.tileset);
      expect(pickObject.content).toEqual(content);
    } else {
      // ModelExperimental case
      expect(pickObject.primitive).toEqual(model);
    }

    if (defined(instanceId)) {
      expect(pickObject.instanceId).toEqual(instanceId);
    }

    var detailPickObject = pickObject.detail;
    expect(detailPickObject).toBeDefined();
    expect(detailPickObject.model).toEqual(model);
    expect(detailPickObject.node).toEqual(renderResources.runtimeNode);
    expect(detailPickObject.primitive).toEqual(
      renderResources.runtimePrimitive
    );
  }

  it("sets the picking variables in render resources for 3D Tiles", function () {
    var renderResources = {
      attributeIndex: 1,
      pickId: undefined,
      shaderBuilder: new ShaderBuilder(),
      model: {
        _resources: [],
        // Setting the content property here makes PickingPipelineStage handle this
        // as part of a tileset.
        content: {
          tileset: {},
        },
      },
      runtimePrimitive: {},
      runtimeNode: {
        node: {},
      },
      uniformMap: {},
    };

    return loadGltf(boxVertexColors).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 = [];

      PickingPipelineStage.process(renderResources, primitive, frameState);

      var shaderBuilder = renderResources.shaderBuilder;
      ShaderBuilderTester.expectHasFragmentUniforms(shaderBuilder, [
        "uniform vec4 czm_pickColor;",
      ]);

      var pickObject =
        context._pickObjects[Object.keys(context._pickObjects)[0]];
      verifyPickObject(pickObject, renderResources);

      var uniformMap = renderResources.uniformMap;
      expect(uniformMap.czm_pickColor).toBeDefined();
      expect(uniformMap.czm_pickColor()).toBeDefined();

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

      expect(renderResources.pickId).toEqual("czm_pickColor");
    });
  });

  it("sets the picking variables in render resources for models", function () {
    var renderResources = {
      attributeIndex: 1,
      pickId: undefined,
      shaderBuilder: new ShaderBuilder(),
      model: {
        _resources: [],
      },
      runtimePrimitive: {
        primitive: {},
      },
      runtimeNode: {
        node: {},
      },
      uniformMap: {},
    };

    return loadGltf(boxVertexColors).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 = [];

      PickingPipelineStage.process(renderResources, primitive, frameState);

      var shaderBuilder = renderResources.shaderBuilder;
      ShaderBuilderTester.expectHasFragmentUniforms(shaderBuilder, [
        "uniform vec4 czm_pickColor;",
      ]);

      var pickObject =
        context._pickObjects[Object.keys(context._pickObjects)[0]];
      verifyPickObject(pickObject, renderResources);

      var uniformMap = renderResources.uniformMap;
      expect(uniformMap.czm_pickColor).toBeDefined();
      expect(uniformMap.czm_pickColor()).toBeDefined();

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

      expect(renderResources.pickId).toEqual("czm_pickColor");
    });
  });

  it("sets the picking variables in render resources with instancing", function () {
    var renderResources = {
      attributeIndex: 1,
      instanceCount: 4,
      pickId: undefined,
      shaderBuilder: new ShaderBuilder(),
      model: {
        _resources: [],
      },
      runtimePrimitive: {
        primitive: {},
      },
      runtimeNode: {
        node: {
          instances: {
            featureIdAttributes: [{}, {}],
          },
        },
      },
      attributes: [],
    };

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

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

      PickingPipelineStage.process(renderResources, primitive, frameState);

      var shaderBuilder = renderResources.shaderBuilder;
      ShaderBuilderTester.expectHasAttributes(shaderBuilder, undefined, [
        "attribute vec4 a_pickColor;",
      ]);
      ShaderBuilderTester.expectHasVaryings(shaderBuilder, [
        "varying vec4 v_pickColor;",
      ]);

      var i = 0;
      for (var key in context._pickObjects) {
        if (context._pickObjects.hasOwnProperty(key)) {
          var pickObject = context._pickObjects[key];
          verifyPickObject(pickObject, renderResources, i++);
        }
      }

      var pickIdAttribute = renderResources.attributes[0];
      expect(pickIdAttribute).toBeDefined();
      expect(pickIdAttribute.index).toEqual(1);
      // Each time an attribute is added, the attribute index should be incremented.
      expect(renderResources.attributeIndex).toEqual(2);
      expect(pickIdAttribute.vertexBuffer).toBeDefined();
      expect(pickIdAttribute.vertexBuffer._sizeInBytes).toEqual(
        renderResources.instanceCount * 4
      );
      expect(pickIdAttribute.instanceDivisor).toEqual(1);

      expect(renderResources.model._resources.length).toEqual(5);

      expect(renderResources.pickId).toEqual("v_pickColor");
    });
  });

  it("sets the picking variables in render resources with feature ID textures", function () {
    var mockModelFeatureTable = {
      batchTexture: {
        pickTexture: "mockPickTexture",
      },
    };

    var renderResources = {
      attributeIndex: 1,
      hasFeatureIds: true,
      pickId: undefined,
      shaderBuilder: new ShaderBuilder(),
      uniformMap: {},
      model: {
        featureIdTextureIndex: 0,
        _resources: [],
        featureTables: [mockModelFeatureTable],
      },
      runtimeNode: {
        node: {},
      },
    };

    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 = [];

      PickingPipelineStage.process(renderResources, primitive, frameState);

      var expectedUniforms = {
        model_pickTexture: mockModelFeatureTable.batchTexture.pickTexture,
      };
      expectUniformMap(renderResources.uniformMap, expectedUniforms);

      var shaderBuilder = renderResources.shaderBuilder;
      ShaderBuilderTester.expectHasFragmentUniforms(shaderBuilder, [
        "uniform sampler2D model_pickTexture;",
      ]);

      expect(renderResources.pickId).toEqual(
        "((feature.id < int(model_featuresLength)) ? texture2D(model_pickTexture, feature.st) : vec4(0.0))"
      );
    });
  });
});