import {
  Cartesian2,
  Cartesian3,
  Matrix2,
  CustomShader,
  CustomShaderMode,
  LightingModel,
  TextureUniform,
  UniformType,
  VaryingType,
} from "../../../Source/Cesium.js";
import createScene from "../../createScene.js";
import pollToPromise from "../../pollToPromise.js";

describe("Scene/ModelExperimental/CustomShader", function () {
  var emptyVertexShader =
    "void vertexMain(VertexInput vsInput, inout vec3 positionMC) {}";
  var emptyFragmentShader =
    "void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material) {}";

  it("constructs with default values", function () {
    var customShader = new CustomShader();

    expect(customShader.mode).toBe(CustomShaderMode.MODIFY_MATERIAL);
    expect(customShader.lightingModel).not.toBeDefined();
    expect(customShader.uniforms).toEqual({});
    expect(customShader.varyings).toEqual({});
    expect(customShader.vertexShaderText).not.toBeDefined();
    expect(customShader.fragmentShaderText).not.toBeDefined();
    expect(customShader.uniformMap).toEqual({});
  });

  it("constructs", function () {
    var customShader = new CustomShader({
      mode: CustomShaderMode.REPLACE_MATERIAL,
      lightingModel: LightingModel.PBR,
      vertexShaderText: emptyVertexShader,
      fragmentShaderText: emptyFragmentShader,
    });

    expect(customShader.mode).toBe(CustomShaderMode.REPLACE_MATERIAL);
    expect(customShader.lightingModel).toBe(LightingModel.PBR);
    expect(customShader.uniforms).toEqual({});
    expect(customShader.varyings).toEqual({});
    expect(customShader.vertexShaderText).toBe(emptyVertexShader);
    expect(customShader.fragmentShaderText).toBe(emptyFragmentShader);
    expect(customShader.uniformMap).toEqual({});
  });

  it("defines uniforms", function () {
    var uniforms = {
      u_time: {
        value: 0,
        type: UniformType.FLOAT,
      },
      u_offset: {
        value: new Cartesian2(1, 2),
        type: UniformType.VEC2,
      },
    };

    var customShader = new CustomShader({
      uniforms: uniforms,
    });

    expect(customShader.uniforms).toBe(uniforms);
    expect(customShader.uniformMap.u_time()).toBe(uniforms.u_time.value);
    expect(customShader.uniformMap.u_offset()).toBe(uniforms.u_offset.value);
  });

  it("setUniform throws for undefined uniformName", function () {
    var customShader = new CustomShader();
    expect(function () {
      return customShader.setUniform(undefined, 45);
    }).toThrowDeveloperError();
  });

  it("setUniform throws for undefined value", function () {
    var customShader = new CustomShader();
    expect(function () {
      return customShader.setUniform("u_time", undefined);
    }).toThrowDeveloperError();
  });

  it("setUniform throws for undeclared uniform", function () {
    var customShader = new CustomShader();
    expect(function () {
      return customShader.setUniform("u_time", 10);
    }).toThrowDeveloperError();
  });

  it("setUniform updates uniform values", function () {
    var uniforms = {
      u_time: {
        value: 0,
        type: UniformType.FLOAT,
      },
      u_offset: {
        value: new Cartesian2(1, 2),
        type: UniformType.VEC2,
      },
    };

    var customShader = new CustomShader({
      uniforms: uniforms,
    });

    expect(customShader.uniformMap.u_time()).toBe(0);
    customShader.setUniform("u_time", 10);
    expect(customShader.uniformMap.u_time()).toBe(10);
  });

  it("setUniform clones vectors", function () {
    var uniforms = {
      u_vector: {
        type: UniformType.VEC3,
        value: new Cartesian3(),
      },
    };

    var customShader = new CustomShader({
      uniforms: uniforms,
    });

    var value = new Cartesian3(1, 0, 0);
    customShader.setUniform("u_vector", value);
    var result = customShader.uniformMap.u_vector();
    expect(result).toEqual(value);
    expect(result).not.toBe(value);
  });

  it("setUniform clones matrices", function () {
    var uniforms = {
      u_matrix: {
        type: UniformType.MAT2,
        value: new Matrix2(),
      },
    };

    var customShader = new CustomShader({
      uniforms: uniforms,
    });

    var value = new Matrix2(2, 0, 0, 2);
    customShader.setUniform("u_matrix", value);
    var result = customShader.uniformMap.u_matrix();
    expect(result).toEqual(value);
    expect(result).not.toBe(value);
  });

  it("declares varyings", function () {
    var varyings = {
      v_dist_from_center: VaryingType.FLOAT,
      v_computedMatrix: VaryingType.MAT4,
    };

    var customShader = new CustomShader({
      varyings: varyings,
    });

    expect(customShader.varyings).toBe(varyings);
  });

  it("detects input variables in the shader text", function () {
    var customShader = new CustomShader({
      vertexShaderText: [
        "void vertexMain(VertexInput vsInput, inout vec3 positionMC)",
        "{",
        "    positionMC += vsInput.attributes.expansion * vsInput.attributes.normalMC;",
        "}",
      ].join("\n"),
      fragmentShaderText: [
        "void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)",
        "{",
        "    material.normalEC = normalize(fsInput.attributes.normalEC);",
        "    material.diffuse = fsInput.attributes.color_0;",
        "    material.specular = fsInput.attributes.positionWC / 1.0e6;",
        "}",
      ].join("\n"),
    });

    var expectedVertexVariables = {
      attributeSet: {
        expansion: true,
        normalMC: true,
      },
    };
    var expectedFragmentVariables = {
      attributeSet: {
        normalEC: true,
        color_0: true,
        positionWC: true,
      },
      materialSet: {
        normalEC: true,
        diffuse: true,
        specular: true,
      },
    };

    expect(customShader.usedVariablesVertex).toEqual(expectedVertexVariables);
    expect(customShader.usedVariablesFragment).toEqual(
      expectedFragmentVariables
    );
  });

  describe("variable validation", function () {
    function makeSingleVariableVS(variableName) {
      return new CustomShader({
        vertexShaderText: [
          "void vertexMain(VertexInput vsInput, inout vec3 positionMC)",
          "{",
          "    positionMC = vsInput.attributes." + variableName + ";",
          "}",
        ].join("\n"),
      });
    }

    function makeSingleVariableFS(variableName) {
      return new CustomShader({
        fragmentShaderText: [
          "void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)",
          "{",
          "    material.diffuse = fsInput.attributes." + variableName + ";",
          "}",
        ].join("\n"),
      });
    }

    it("validates position", function () {
      expect(function () {
        return makeSingleVariableVS("position");
      }).toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableVS("positionMC");
      }).not.toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableVS("positionWC");
      }).toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableVS("positionEC");
      }).toThrowDeveloperError();

      expect(function () {
        return makeSingleVariableFS("position");
      }).toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableFS("positionMC");
      }).not.toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableFS("positionWC");
      }).not.toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableFS("positionEC");
      }).not.toThrowDeveloperError();
    });

    it("validates normal", function () {
      expect(function () {
        return makeSingleVariableVS("normal");
      }).toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableVS("normalMC");
      }).not.toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableVS("normalEC");
      }).toThrowDeveloperError();

      expect(function () {
        return makeSingleVariableFS("normal");
      }).toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableFS("normalMC");
      }).toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableFS("normalEC");
      }).not.toThrowDeveloperError();
    });

    it("validates tangent", function () {
      expect(function () {
        return makeSingleVariableVS("tangent");
      }).toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableVS("tangentMC");
      }).not.toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableVS("tangentEC");
      }).toThrowDeveloperError();

      expect(function () {
        return makeSingleVariableFS("tangent");
      }).toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableFS("tangentMC");
      }).toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableFS("tangentEC");
      }).not.toThrowDeveloperError();
    });

    it("validates bitangent", function () {
      expect(function () {
        return makeSingleVariableVS("bitangent");
      }).toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableVS("bitangentMC");
      }).not.toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableVS("bitangentEC");
      }).toThrowDeveloperError();

      expect(function () {
        return makeSingleVariableFS("bitangent");
      }).toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableFS("bitangentMC");
      }).toThrowDeveloperError();
      expect(function () {
        return makeSingleVariableFS("bitangentEC");
      }).not.toThrowDeveloperError();
    });
  });

  // asynchronous code is only needed if texture uniforms are used.
  describe(
    "texture uniforms",
    function () {
      var scene;

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

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

      var shaders = [];
      afterEach(function () {
        for (var i = 0; i < shaders.length; i++) {
          var shader = shaders[i];
          if (!shader.isDestroyed()) {
            shader.destroy();
          }
        }
        shaders.length = 0;
      });

      var blueUrl = "Data/Images/Blue2x2.png";
      var greenUrl = "Data/Images/Green1x4.png";

      function waitForTextureLoad(customShader, textureId) {
        var textureManager = customShader._textureManager;
        var oldValue = textureManager.getTexture(textureId);
        return pollToPromise(function () {
          scene.renderForSpecs();
          customShader.update(scene.frameState);

          // Check that the texture changed. This allows waitForTextureLoad()
          // to be called multiple times in one promise chain, which is needed
          // for testing setUniform()
          return textureManager.getTexture(textureId) !== oldValue;
        }).then(function () {
          return textureManager.getTexture(textureId);
        });
      }

      it("supports texture uniforms", function () {
        var customShader = new CustomShader({
          vertexShaderText: emptyVertexShader,
          fragmentShaderText: emptyFragmentShader,
          uniforms: {
            u_blue: {
              type: UniformType.SAMPLER_2D,
              value: new TextureUniform({
                url: blueUrl,
              }),
            },
          },
        });
        shaders.push(customShader);
        expect(customShader.uniformMap.u_blue).toBeDefined();
        expect(customShader.uniformMap.u_blue()).not.toBeDefined();

        return waitForTextureLoad(customShader, "u_blue").then(function (
          texture
        ) {
          expect(customShader.uniformMap.u_blue()).toBe(texture);
          expect(texture.width).toBe(2);
          expect(texture.height).toBe(2);
        });
      });

      it("can change texture uniform value", function () {
        var customShader = new CustomShader({
          vertexShaderText: emptyVertexShader,
          fragmentShaderText: emptyFragmentShader,
          uniforms: {
            u_testTexture: {
              type: UniformType.SAMPLER_2D,
              value: new TextureUniform({
                url: blueUrl,
              }),
            },
          },
        });
        shaders.push(customShader);

        return waitForTextureLoad(customShader, "u_testTexture").then(function (
          blueTexture
        ) {
          expect(customShader.uniformMap.u_testTexture()).toBe(blueTexture);
          expect(blueTexture.width).toBe(2);
          expect(blueTexture.height).toBe(2);
          customShader.setUniform(
            "u_testTexture",
            new TextureUniform({
              url: greenUrl,
            })
          );
          return waitForTextureLoad(customShader, "u_testTexture").then(
            function (greenTexture) {
              expect(customShader.uniformMap.u_testTexture()).toBe(
                greenTexture
              );
              expect(greenTexture.width).toBe(1);
              expect(greenTexture.height).toBe(4);
            }
          );
        });
      });

      it("destroys", function () {
        var customShader = new CustomShader({
          vertexShaderText: emptyVertexShader,
          fragmentShaderText: emptyFragmentShader,
          uniforms: {
            u_blue: {
              type: UniformType.SAMPLER_2D,
              value: new TextureUniform({
                url: blueUrl,
              }),
            },
          },
        });
        shaders.push(customShader);

        return waitForTextureLoad(customShader, "u_blue").then(function (
          texture
        ) {
          expect(customShader.isDestroyed()).toBe(false);
          expect(texture.isDestroyed()).toBe(false);

          customShader.destroy();

          expect(customShader.isDestroyed()).toBe(true);
          expect(texture.isDestroyed()).toBe(true);
        });
      });
    },
    "WebGL"
  );
});