import { Cartesian2 } from "../../Source/Cesium.js";
import { Cartesian3 } from "../../Source/Cesium.js";
import { Cartesian4 } from "../../Source/Cesium.js";
import { Math as CesiumMath } from "../../Source/Cesium.js";
import { Matrix4 } from "../../Source/Cesium.js";
import { PerspectiveOffCenterFrustum } from "../../Source/Cesium.js";

describe("Core/PerspectiveOffCenterFrustum", function () {
  var frustum, planes;

  beforeEach(function () {
    frustum = new PerspectiveOffCenterFrustum();
    frustum.right = 1.0;
    frustum.left = -frustum.right;
    frustum.top = 1.0;
    frustum.bottom = -frustum.top;
    frustum.near = 1.0;
    frustum.far = 2.0;
    planes = frustum.computeCullingVolume(
      new Cartesian3(),
      Cartesian3.negate(Cartesian3.UNIT_Z, new Cartesian3()),
      Cartesian3.UNIT_Y
    ).planes;
  });

  it("constructs", function () {
    var options = {
      left: -1.0,
      right: 2.0,
      top: 5.0,
      bottom: -1.0,
      near: 3.0,
      far: 4.0,
    };
    var f = new PerspectiveOffCenterFrustum(options);
    expect(f.width).toEqual(options.width);
    expect(f.aspectRatio).toEqual(options.aspectRatio);
    expect(f.near).toEqual(options.near);
    expect(f.far).toEqual(options.far);
  });

  it("default constructs", function () {
    var f = new PerspectiveOffCenterFrustum();
    expect(f.left).toBeUndefined();
    expect(f.right).toBeUndefined();
    expect(f.top).toBeUndefined();
    expect(f.bottom).toBeUndefined();
    expect(f.near).toEqual(1.0);
    expect(f.far).toEqual(500000000.0);
  });

  it("out of range near plane throws an exception", function () {
    frustum.near = -1.0;
    expect(function () {
      return frustum.projectionMatrix;
    }).toThrowDeveloperError();
  });

  it("negative far plane throws an exception", function () {
    frustum.far = -1.0;
    expect(function () {
      return frustum.projectionMatrix;
    }).toThrowDeveloperError();
  });

  it("computeCullingVolume with no position throws an exception", function () {
    expect(function () {
      return frustum.computeCullingVolume();
    }).toThrowDeveloperError();
  });

  it("computeCullingVolume with no direction throws an exception", function () {
    expect(function () {
      return frustum.computeCullingVolume(new Cartesian3());
    }).toThrowDeveloperError();
  });

  it("computeCullingVolume with no up throws an exception", function () {
    expect(function () {
      return frustum.computeCullingVolume(new Cartesian3(), new Cartesian3());
    }).toThrowDeveloperError();
  });

  it("get frustum left plane", function () {
    var leftPlane = planes[0];
    var x = 1.0 / Math.sqrt(2.0);
    var expectedResult = new Cartesian4(x, 0.0, -x, 0.0);
    expect(leftPlane).toEqualEpsilon(expectedResult, CesiumMath.EPSILON15);
  });

  it("get frustum right plane", function () {
    var rightPlane = planes[1];
    var x = 1.0 / Math.sqrt(2.0);
    var expectedResult = new Cartesian4(-x, 0.0, -x, 0.0);
    expect(rightPlane).toEqualEpsilon(expectedResult, CesiumMath.EPSILON15);
  });

  it("get frustum bottom plane", function () {
    var bottomPlane = planes[2];
    var x = 1.0 / Math.sqrt(2.0);
    var expectedResult = new Cartesian4(0.0, x, -x, 0.0);
    expect(bottomPlane).toEqualEpsilon(expectedResult, CesiumMath.EPSILON15);
  });

  it("get frustum top plane", function () {
    var topPlane = planes[3];
    var x = 1.0 / Math.sqrt(2.0);
    var expectedResult = new Cartesian4(0.0, -x, -x, 0.0);
    expect(topPlane).toEqualEpsilon(expectedResult, CesiumMath.EPSILON15);
  });

  it("get frustum near plane", function () {
    var nearPlane = planes[4];
    var expectedResult = new Cartesian4(0.0, 0.0, -1.0, -1.0);
    expect(nearPlane).toEqualEpsilon(expectedResult, CesiumMath.EPSILON15);
  });

  it("get frustum far plane", function () {
    var farPlane = planes[5];
    var expectedResult = new Cartesian4(0.0, 0.0, 1.0, 2.0);
    expect(farPlane).toEqualEpsilon(expectedResult, CesiumMath.EPSILON15);
  });

  it("get perspective projection matrix", function () {
    var projectionMatrix = frustum.projectionMatrix;

    var top = frustum.top;
    var bottom = frustum.bottom;
    var right = frustum.right;
    var left = frustum.left;
    var near = frustum.near;
    var far = frustum.far;
    var expected = Matrix4.computePerspectiveOffCenter(
      left,
      right,
      bottom,
      top,
      near,
      far,
      new Matrix4()
    );

    expect(projectionMatrix).toEqualEpsilon(expected, CesiumMath.EPSILON6);
  });

  it("get infinite perspective matrix", function () {
    var top = frustum.top;
    var bottom = frustum.bottom;
    var right = frustum.right;
    var left = frustum.left;
    var near = frustum.near;

    var expected = Matrix4.computeInfinitePerspectiveOffCenter(
      left,
      right,
      bottom,
      top,
      near,
      new Matrix4()
    );
    expect(expected).toEqual(frustum.infiniteProjectionMatrix);
  });

  it("get pixel dimensions throws without canvas height", function () {
    expect(function () {
      return frustum.getPixelDimensions(
        1.0,
        undefined,
        1.0,
        1.0,
        new Cartesian2()
      );
    }).toThrowDeveloperError();
  });

  it("get pixel dimensions throws without canvas width", function () {
    expect(function () {
      return frustum.getPixelDimensions(
        undefined,
        1.0,
        1.0,
        1.0,
        new Cartesian2()
      );
    }).toThrowDeveloperError();
  });

  it("get pixel dimensions throws with canvas width less than or equal to zero", function () {
    expect(function () {
      return frustum.getPixelDimensions(0.0, 1.0, 1.0, 1.0, new Cartesian2());
    }).toThrowDeveloperError();
  });

  it("get pixel dimensions throws with canvas height less than or equal to zero", function () {
    expect(function () {
      return frustum.getPixelDimensions(1.0, 0.0, 1.0, 1.0, new Cartesian2());
    }).toThrowDeveloperError();
  });

  it("get pixel dimensions throws without pixel ratio", function () {
    expect(function () {
      return frustum.getPixelDimensions(
        1.0,
        1.0,
        1.0,
        undefined,
        new Cartesian2()
      );
    }).toThrowDeveloperError();
  });

  it("get pixel dimensions throws with pixel ratio less than or equal to zero", function () {
    expect(function () {
      return frustum.getPixelDimensions(1.0, 1.0, 1.0, 0.0, new Cartesian2());
    }).toThrowDeveloperError();
  });

  it("get pixel dimensions", function () {
    var pixelSize = frustum.getPixelDimensions(
      1.0,
      1.0,
      1.0,
      1.0,
      new Cartesian2()
    );
    expect(pixelSize.x).toEqual(2.0);
    expect(pixelSize.y).toEqual(2.0);
  });

  it("get pixel dimensions with pixel ratio", function () {
    var pixelSize = frustum.getPixelDimensions(
      1.0,
      1.0,
      1.0,
      2.0,
      new Cartesian2()
    );
    expect(pixelSize.x).toEqual(4.0);
    expect(pixelSize.y).toEqual(4.0);
  });

  it("equals", function () {
    var frustum2 = new PerspectiveOffCenterFrustum();
    frustum2.right = 1.0;
    frustum2.left = -frustum.right;
    frustum2.top = 1.0;
    frustum2.bottom = -frustum.top;
    frustum2.near = 1.0;
    frustum2.far = 2.0;
    frustum2.position = new Cartesian3();
    frustum2.direction = Cartesian3.negate(Cartesian3.UNIT_Z, new Cartesian3());
    frustum2.up = Cartesian3.UNIT_Y;

    expect(frustum).toEqual(frustum2);
  });

  it("equals epsilon", function () {
    var frustum2 = new PerspectiveOffCenterFrustum();
    frustum2.right = 1.0;
    frustum2.left = -frustum.right;
    frustum2.top = 1.0;
    frustum2.bottom = -frustum.top;
    frustum2.near = 1.0;
    frustum2.far = 2.0;
    expect(frustum.equalsEpsilon(frustum2, CesiumMath.EPSILON7)).toEqual(true);

    var frustum3 = new PerspectiveOffCenterFrustum();
    frustum3.right = 1.01;
    frustum3.left = -frustum.right;
    frustum3.top = 1.01;
    frustum3.bottom = -frustum.top;
    frustum3.near = 1.01;
    frustum3.far = 1.99;
    expect(frustum.equalsEpsilon(frustum3, CesiumMath.EPSILON1)).toEqual(true);

    var frustum4 = new PerspectiveOffCenterFrustum();
    frustum4.right = 1.1;
    frustum4.left = -frustum.right;
    frustum4.top = 1.0;
    frustum4.bottom = -frustum.top;
    frustum4.near = 1.0;
    frustum4.far = 2.0;
    expect(frustum.equalsEpsilon(frustum4, CesiumMath.EPSILON2)).toEqual(false);
  });

  it("equals undefined", function () {
    expect(frustum.equals()).toEqual(false);
  });

  it("throws with undefined frustum parameters", function () {
    var frustum = new PerspectiveOffCenterFrustum();
    expect(function () {
      return frustum.infiniteProjectionMatrix;
    }).toThrowDeveloperError();
  });

  it("clone", function () {
    var frustum2 = frustum.clone();
    expect(frustum).toEqual(frustum2);
  });

  it("clone with result parameter", function () {
    var result = new PerspectiveOffCenterFrustum();
    var frustum2 = frustum.clone(result);
    expect(frustum2).toBe(result);
    expect(frustum).toEqual(frustum2);
  });
});