import {
  BufferLoader,
  clone,
  GltfJsonLoader,
  Resource,
  ResourceCache,
  when,
} from "../../Source/Cesium.js";
import generateJsonBuffer from "../generateJsonBuffer.js";

describe("Scene/GltfJsonLoader", function () {
  var gltfUri = "https://example.com/model.glb";
  var gltfResource = new Resource({
    url: gltfUri,
  });
  var bufferResource = new Resource({
    url: "https://example.com/external.bin",
  });

  var gltf1 = {
    asset: {
      version: "1.0",
    },
    buffers: {
      buffer: {
        uri: "external.bin",
      },
    },
    bufferViews: {
      bufferView: {
        buffer: "buffer",
        byteOffset: 0,
      },
    },
    accessors: {
      accessor: {
        bufferView: "bufferView",
        byteOffset: 0,
        componentType: 5126,
        type: "VEC3",
        count: 1,
      },
    },
    meshes: {
      mesh: {
        primitives: [
          {
            attributes: {
              POSITION: "accessor",
            },
          },
        ],
      },
    },
    nodes: {
      node: {
        meshes: ["mesh"],
      },
    },
    scene: "scene",
    scenes: {
      scene: {
        nodes: ["node"],
      },
    },
  };

  var gltf1Updated = {
    asset: {
      version: "2.0",
    },
    buffers: [
      {
        uri: "external.bin",
        name: "buffer",
        byteLength: 12,
      },
    ],
    bufferViews: [
      {
        buffer: 0,
        byteOffset: 0,
        name: "bufferView",
        byteLength: 12,
        byteStride: 12,
        target: 34962,
      },
    ],
    accessors: [
      {
        bufferView: 0,
        byteOffset: 0,
        componentType: 5126,
        type: "VEC3",
        count: 1,
        name: "accessor",
        min: [0, 0, 0],
        max: [0, 0, 0],
        normalized: false,
      },
    ],
    meshes: [
      {
        primitives: [
          {
            attributes: {
              POSITION: 0,
            },
            mode: 4,
            material: 0,
          },
        ],
        name: "mesh",
      },
    ],
    nodes: [
      {
        name: "node",
        mesh: 0,
        matrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
      },
    ],
    scene: 0,
    scenes: [
      {
        nodes: [0],
        name: "scene",
      },
    ],
    materials: [
      {
        name: "default",
        emissiveFactor: [0, 0, 0],
        alphaMode: "OPAQUE",
        doubleSided: false,
      },
    ],
  };

  var gltf2 = {
    asset: {
      version: "2.0",
    },
    buffers: [
      {
        uri: "external.bin",
        byteLength: 12,
      },
    ],
    bufferViews: [
      {
        buffer: 0,
        byteOffset: 0,
        byteLength: 12,
      },
    ],
    accessors: [
      {
        bufferView: 0,
        byteOffset: 0,
        componentType: 5126,
        type: "VEC3",
        count: 1,
        min: [0, 0, 0],
        max: [0, 0, 0],
      },
    ],
    meshes: [
      {
        primitives: [
          {
            attributes: {
              POSITION: 0,
            },
          },
        ],
      },
    ],
    nodes: [
      {
        mesh: 0,
        matrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
      },
    ],
    scene: 0,
    scenes: [
      {
        nodes: [0],
      },
    ],
  };

  var gltf2Updated = {
    asset: {
      version: "2.0",
    },
    buffers: [
      {
        uri: "external.bin",
        byteLength: 12,
      },
    ],
    bufferViews: [
      {
        buffer: 0,
        byteOffset: 0,
        byteLength: 12,
        byteStride: 12,
        target: 34962,
      },
    ],
    accessors: [
      {
        bufferView: 0,
        byteOffset: 0,
        componentType: 5126,
        type: "VEC3",
        count: 1,
        min: [0, 0, 0],
        max: [0, 0, 0],
        normalized: false,
      },
    ],
    meshes: [
      {
        primitives: [
          {
            attributes: {
              POSITION: 0,
            },
            mode: 4,
            material: 0,
          },
        ],
      },
    ],
    nodes: [
      {
        mesh: 0,
        matrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
      },
    ],
    scene: 0,
    scenes: [
      {
        nodes: [0],
      },
    ],
    materials: [
      {
        name: "default",
        emissiveFactor: [0, 0, 0],
        alphaMode: "OPAQUE",
        doubleSided: false,
      },
    ],
  };

  function createGlb1(json) {
    var jsonBuffer = generateJsonBuffer(json, 12, 4);
    var positionBuffer = new Float32Array([0.0, 0.0, 0.0]);
    var binaryBuffer = new Uint8Array(positionBuffer.buffer);
    var glbLength = 20 + jsonBuffer.byteLength + binaryBuffer.byteLength;
    var glb = new Uint8Array(glbLength);
    var dataView = new DataView(glb.buffer, glb.byteOffset, glb.byteLength);

    // Write binary glTF header (magic, version, length)
    var byteOffset = 0;
    dataView.setUint32(byteOffset, 0x46546c67, true);
    byteOffset += 4;
    dataView.setUint32(byteOffset, 1, true);
    byteOffset += 4;
    dataView.setUint32(byteOffset, glbLength, true);
    byteOffset += 4;
    dataView.setUint32(byteOffset, jsonBuffer.byteLength, true);
    byteOffset += 4;
    dataView.setUint32(byteOffset, 0, true);
    byteOffset += 4;

    // Write JSON Chunk
    glb.set(jsonBuffer, byteOffset);
    byteOffset += jsonBuffer.byteLength;

    // Write Binary Chunk
    glb.set(binaryBuffer, byteOffset);

    return glb;
  }

  function createGlb2(json) {
    var jsonBuffer = generateJsonBuffer(json, 12, 4);
    var positionBuffer = new Float32Array([0.0, 0.0, 0.0]);
    var binaryBuffer = new Uint8Array(positionBuffer.buffer);
    var glbLength =
      12 + 8 + jsonBuffer.byteLength + 8 + binaryBuffer.byteLength;
    var glb = new Uint8Array(glbLength);
    var dataView = new DataView(glb.buffer, glb.byteOffset, glb.byteLength);

    // Write binary glTF header (magic, version, length)
    var byteOffset = 0;
    dataView.setUint32(byteOffset, 0x46546c67, true);
    byteOffset += 4;
    dataView.setUint32(byteOffset, 2, true);
    byteOffset += 4;
    dataView.setUint32(byteOffset, glbLength, true);
    byteOffset += 4;

    // Write JSON Chunk header (length, type)
    dataView.setUint32(byteOffset, jsonBuffer.byteLength, true);
    byteOffset += 4;
    dataView.setUint32(byteOffset, 0x4e4f534a, true);
    byteOffset += 4;

    // Write JSON Chunk
    glb.set(jsonBuffer, byteOffset);
    byteOffset += jsonBuffer.byteLength;

    // Write Binary Chunk header (length, type)
    dataView.setUint32(byteOffset, binaryBuffer.byteLength);
    byteOffset += 4;
    dataView.setUint32(byteOffset, 0x004e4942, true);
    byteOffset += 4;

    // Write Binary Chunk
    glb.set(binaryBuffer, byteOffset);

    return glb;
  }

  afterEach(function () {
    ResourceCache.clearForSpecs();
  });

  it("throws if resourceCache is undefined", function () {
    expect(function () {
      return new GltfJsonLoader({
        resourceCache: undefined,
        gltfResource: gltfResource,
        baseResource: gltfResource,
      });
    }).toThrowDeveloperError();
  });

  it("throws if gltfResource is undefined", function () {
    expect(function () {
      return new GltfJsonLoader({
        resourceCache: ResourceCache,
        gltfResource: undefined,
        baseResource: gltfResource,
      });
    }).toThrowDeveloperError();
  });

  it("throws if baseResource is undefined", function () {
    expect(function () {
      return new GltfJsonLoader({
        resourceCache: ResourceCache,
        gltfResource: gltfResource,
        baseResource: undefined,
      });
    }).toThrowDeveloperError();
  });

  it("rejects promise if resource fails to load", function () {
    var error = new Error("404 Not Found");
    spyOn(GltfJsonLoader.prototype, "_fetchGltf").and.returnValue(
      when.reject(error)
    );

    var gltfJsonLoader = new GltfJsonLoader({
      resourceCache: ResourceCache,
      gltfResource: gltfResource,
      baseResource: gltfResource,
    });

    gltfJsonLoader.load();

    return gltfJsonLoader.promise
      .then(function (gltfJsonLoader) {
        fail();
      })
      .otherwise(function (runtimeError) {
        expect(runtimeError.message).toBe(
          "Failed to load glTF: https://example.com/model.glb\n404 Not Found"
        );
      });
  });

  it("rejects promise if glTF fails to process", function () {
    var arrayBuffer = generateJsonBuffer(gltf1).buffer;

    spyOn(GltfJsonLoader.prototype, "_fetchGltf").and.returnValue(
      when.resolve(arrayBuffer)
    );

    var error = new Error("404 Not Found");
    spyOn(Resource.prototype, "fetchArrayBuffer").and.returnValue(
      when.reject(error)
    );

    var gltfJsonLoader = new GltfJsonLoader({
      resourceCache: ResourceCache,
      gltfResource: gltfResource,
      baseResource: gltfResource,
    });

    gltfJsonLoader.load();

    return gltfJsonLoader.promise
      .then(function (gltfJsonLoader) {
        fail();
      })
      .otherwise(function (runtimeError) {
        expect(runtimeError.message).toBe(
          "Failed to load glTF: https://example.com/model.glb\nFailed to load external buffer: https://example.com/external.bin\n404 Not Found"
        );
      });
  });

  it("rejects promise if glTF fails to process from typed array", function () {
    var typedArray = createGlb1(gltf1);

    var error = new Error("404 Not Found");
    spyOn(Resource.prototype, "fetchArrayBuffer").and.returnValue(
      when.reject(error)
    );

    var gltfJsonLoader = new GltfJsonLoader({
      resourceCache: ResourceCache,
      gltfResource: gltfResource,
      baseResource: gltfResource,
      typedArray: typedArray,
    });

    gltfJsonLoader.load();

    return gltfJsonLoader.promise
      .then(function (gltfJsonLoader) {
        fail();
      })
      .otherwise(function (runtimeError) {
        expect(runtimeError.message).toBe(
          "Failed to load glTF: https://example.com/model.glb\nFailed to load external buffer: https://example.com/external.bin\n404 Not Found"
        );
      });
  });

  it("loads glTF 1.0", function () {
    var arrayBuffer = generateJsonBuffer(gltf1).buffer;

    spyOn(GltfJsonLoader.prototype, "_fetchGltf").and.returnValue(
      when.resolve(arrayBuffer)
    );

    spyOn(Resource.prototype, "fetchArrayBuffer").and.returnValue(
      when.resolve(new Float32Array([0.0, 0.0, 0.0]).buffer)
    );

    var gltfJsonLoader = new GltfJsonLoader({
      resourceCache: ResourceCache,
      gltfResource: gltfResource,
      baseResource: gltfResource,
    });

    gltfJsonLoader.load();

    return gltfJsonLoader.promise.then(function (gltfJsonLoader) {
      var gltf = gltfJsonLoader.gltf;
      expect(gltf).toEqual(gltf1Updated);
    });
  });

  it("loads glTF 1.0 binary", function () {
    var gltf1Binary = clone(gltf1, true);
    gltf1Binary.buffers = {
      binary_glTF: {
        type: "arraybuffer",
        byteLength: 12,
        uri: "data:,",
      },
    };
    gltf1Binary.extensionsUsed = ["KHR_binary_glTF"];
    gltf1Binary.bufferViews.bufferView.buffer = "binary_glTF";

    var gltf1BinaryUpdated = clone(gltf1Updated, true);
    gltf1BinaryUpdated.buffers[0].name = "binary_glTF";
    delete gltf1BinaryUpdated.buffers[0].uri;

    var arrayBuffer = createGlb1(gltf1Binary).buffer;

    spyOn(GltfJsonLoader.prototype, "_fetchGltf").and.returnValue(
      when.resolve(arrayBuffer)
    );

    var gltfJsonLoader = new GltfJsonLoader({
      resourceCache: ResourceCache,
      gltfResource: gltfResource,
      baseResource: gltfResource,
    });

    gltfJsonLoader.load();

    return gltfJsonLoader.promise.then(function (gltfJsonLoader) {
      var gltf = gltfJsonLoader.gltf;
      expect(gltf).toEqual(gltf1BinaryUpdated);
    });
  });

  it("loads glTF 1.0 with data uri", function () {
    var gltf1DataUri = clone(gltf1, true);
    gltf1DataUri.buffers.buffer = {
      uri: "data:application/octet-stream;base64,AAAAAAAAAAAAAAAA",
    };

    var gltf1DataUriUpdated = clone(gltf1Updated, true);
    delete gltf1DataUriUpdated.buffers[0].uri;

    var arrayBuffer = generateJsonBuffer(gltf1DataUri).buffer;

    spyOn(GltfJsonLoader.prototype, "_fetchGltf").and.returnValue(
      when.resolve(arrayBuffer)
    );

    var gltfJsonLoader = new GltfJsonLoader({
      resourceCache: ResourceCache,
      gltfResource: gltfResource,
      baseResource: gltfResource,
    });

    gltfJsonLoader.load();

    return gltfJsonLoader.promise.then(function (gltfJsonLoader) {
      var gltf = gltfJsonLoader.gltf;
      expect(gltf).toEqual(gltf1DataUriUpdated);
    });
  });

  it("loads glTF 2.0", function () {
    var arrayBuffer = generateJsonBuffer(gltf2).buffer;

    spyOn(GltfJsonLoader.prototype, "_fetchGltf").and.returnValue(
      when.resolve(arrayBuffer)
    );

    spyOn(Resource.prototype, "fetchArrayBuffer").and.returnValue(
      when.resolve(new Float32Array([0.0, 0.0, 0.0]).buffer)
    );

    var gltfJsonLoader = new GltfJsonLoader({
      resourceCache: ResourceCache,
      gltfResource: gltfResource,
      baseResource: gltfResource,
    });

    gltfJsonLoader.load();

    return gltfJsonLoader.promise.then(function (gltfJsonLoader) {
      var gltf = gltfJsonLoader.gltf;
      expect(gltf).toEqual(gltf2Updated);
    });
  });

  it("loads glTF 2.0 binary", function () {
    var gltf2Binary = clone(gltf2, true);
    delete gltf2Binary.buffers[0].uri;

    var gltf2BinaryUpdated = clone(gltf2Updated, true);
    delete gltf2BinaryUpdated.buffers[0].uri;

    var arrayBuffer = createGlb2(gltf2Binary).buffer;

    spyOn(GltfJsonLoader.prototype, "_fetchGltf").and.returnValue(
      when.resolve(arrayBuffer)
    );

    var gltfJsonLoader = new GltfJsonLoader({
      resourceCache: ResourceCache,
      gltfResource: gltfResource,
      baseResource: gltfResource,
    });

    gltfJsonLoader.load();

    return gltfJsonLoader.promise.then(function (gltfJsonLoader) {
      var gltf = gltfJsonLoader.gltf;
      expect(gltf).toEqual(gltf2BinaryUpdated);
    });
  });

  it("loads glTF 2.0 with data uri", function () {
    var gltf2DataUri = clone(gltf2, true);
    gltf2DataUri.buffers[0].uri =
      "data:application/octet-stream;base64,AAAAAAAAAAAAAAAA";

    var gltf2DataUriUpdated = clone(gltf2Updated, true);
    delete gltf2DataUriUpdated.buffers[0].uri;

    var arrayBuffer = generateJsonBuffer(gltf2DataUri).buffer;

    spyOn(GltfJsonLoader.prototype, "_fetchGltf").and.returnValue(
      when.resolve(arrayBuffer)
    );

    var gltfJsonLoader = new GltfJsonLoader({
      resourceCache: ResourceCache,
      gltfResource: gltfResource,
      baseResource: gltfResource,
    });

    gltfJsonLoader.load();

    return gltfJsonLoader.promise.then(function (gltfJsonLoader) {
      var gltf = gltfJsonLoader.gltf;
      expect(gltf).toEqual(gltf2DataUriUpdated);
    });
  });

  it("loads typed array", function () {
    var gltf2Binary = clone(gltf2, true);
    delete gltf2Binary.buffers[0].uri;

    var gltf2BinaryUpdated = clone(gltf2Updated, true);
    delete gltf2BinaryUpdated.buffers[0].uri;

    var typedArray = createGlb2(gltf2Binary);

    var gltfJsonLoader = new GltfJsonLoader({
      resourceCache: ResourceCache,
      gltfResource: gltfResource,
      baseResource: gltfResource,
      typedArray: typedArray,
    });

    gltfJsonLoader.load();

    return gltfJsonLoader.promise.then(function (gltfJsonLoader) {
      var gltf = gltfJsonLoader.gltf;
      expect(gltf).toEqual(gltf2BinaryUpdated);
    });
  });

  it("destroys", function () {
    var gltf2Binary = clone(gltf2, true);
    delete gltf2Binary.buffers[0].uri;

    var arrayBuffer = createGlb2(gltf2Binary).buffer;

    spyOn(GltfJsonLoader.prototype, "_fetchGltf").and.returnValue(
      when.resolve(arrayBuffer)
    );

    var unloadBuffer = spyOn(
      BufferLoader.prototype,
      "unload"
    ).and.callThrough();

    var gltfJsonLoader = new GltfJsonLoader({
      resourceCache: ResourceCache,
      gltfResource: gltfResource,
      baseResource: gltfResource,
    });

    gltfJsonLoader.load();

    return gltfJsonLoader.promise.then(function (gltfJsonLoader) {
      expect(gltfJsonLoader.gltf).toBeDefined();
      expect(gltfJsonLoader.isDestroyed()).toBe(false);

      gltfJsonLoader.destroy();

      expect(gltfJsonLoader.gltf).not.toBeDefined();
      expect(gltfJsonLoader.isDestroyed()).toBe(true);
      expect(unloadBuffer).toHaveBeenCalled();
    });
  });

  function resolvesGltfAfterDestroy(reject) {
    var deferredPromise = when.defer();
    spyOn(GltfJsonLoader.prototype, "_fetchGltf").and.returnValue(
      deferredPromise.promise
    );

    var arrayBuffer = generateJsonBuffer(gltf2).buffer;

    var gltfJsonLoader = new GltfJsonLoader({
      resourceCache: ResourceCache,
      gltfResource: gltfResource,
      baseResource: gltfResource,
    });

    expect(gltfJsonLoader.gltf).not.toBeDefined();

    gltfJsonLoader.load();
    gltfJsonLoader.destroy();

    if (reject) {
      deferredPromise.reject(new Error());
    } else {
      deferredPromise.resolve(arrayBuffer);
    }

    expect(gltfJsonLoader.gltf).not.toBeDefined();
    expect(gltfJsonLoader.isDestroyed()).toBe(true);
  }

  it("handles resolving glTF after destroy", function () {
    resolvesGltfAfterDestroy(false);
  });

  it("handles rejecting glTF after destroy", function () {
    resolvesGltfAfterDestroy(true);
  });

  function resolvesProcessedGltfAfterDestroy(reject) {
    spyOn(GltfJsonLoader.prototype, "_fetchGltf").and.returnValue(
      when.resolve(generateJsonBuffer(gltf2).buffer)
    );

    var buffer = new Float32Array([0.0, 0.0, 0.0]).buffer;
    var deferredPromise = when.defer();
    spyOn(Resource.prototype, "fetchArrayBuffer").and.returnValue(
      deferredPromise.promise
    );

    var gltfJsonLoader = new GltfJsonLoader({
      resourceCache: ResourceCache,
      gltfResource: gltfResource,
      baseResource: gltfResource,
    });

    expect(gltfJsonLoader.gltf).not.toBeDefined();

    gltfJsonLoader.load();
    gltfJsonLoader.destroy();

    deferredPromise.resolve(buffer);

    expect(gltfJsonLoader.gltf).not.toBeDefined();
    expect(gltfJsonLoader.isDestroyed()).toBe(true);
  }

  it("handles resolving processed glTF after destroy", function () {
    resolvesProcessedGltfAfterDestroy(false);
  });

  it("handles rejecting processed glTF after destroy", function () {
    resolvesProcessedGltfAfterDestroy(true);
  });

  function resolvesTypedArrayAfterDestroy(reject) {
    var typedArray = generateJsonBuffer(gltf1);

    var buffer = new Float32Array([0.0, 0.0, 0.0]).buffer;
    var deferredPromise = when.defer();
    spyOn(Resource.prototype, "fetchArrayBuffer").and.returnValue(
      deferredPromise.promise
    );

    // Load a copy of the buffer into the cache so that the buffer loader
    // promise resolves even if the glTF loader is destroyed
    var bufferLoaderCopy = ResourceCache.loadExternalBuffer({
      resource: bufferResource,
    });

    var gltfJsonLoader = new GltfJsonLoader({
      resourceCache: ResourceCache,
      gltfResource: gltfResource,
      baseResource: gltfResource,
      typedArray: typedArray,
    });

    expect(gltfJsonLoader.gltf).not.toBeDefined();

    gltfJsonLoader.load();
    gltfJsonLoader.destroy();

    if (reject) {
      deferredPromise.reject(new Error());
    } else {
      deferredPromise.resolve(buffer);
    }

    expect(gltfJsonLoader.gltf).not.toBeDefined();
    expect(gltfJsonLoader.isDestroyed()).toBe(true);

    ResourceCache.unload(bufferLoaderCopy);
  }

  it("handles resolving typed array after destroy", function () {
    return resolvesTypedArrayAfterDestroy(false);
  });

  it("handles rejecting typed array after destroy", function () {
    return resolvesTypedArrayAfterDestroy(true);
  });
});
