import { CogniteWellsClient, TrajectoryFilterRequest } from "src";
import { TrajectoryData } from "../../model/trajectoryData";
import { TrajectoryInterpolationRequest } from "../../model/trajectoryInterpolationRequest";
import { TrueVerticalDepths } from "../../model/trueVerticalDepths";
import { setupLoggedInClient } from "../testUtils";
import { expectContainAll } from "./utils/expectContainAll";

let client: CogniteWellsClient;
beforeAll(async () => {
  client = await setupLoggedInClient();
});

test("fetch trajectories by multiple wellbores", async () => {
  expect(client).not.toBe(undefined);
  const filter: TrajectoryFilterRequest = {
    filter: {
      wellboreIds: [
        { assetExternalId: "VOLVE:13/10-F-11 T2" },
        { assetExternalId: "VOLVE:13/10-F-11 B" },
      ],
    },
  };

  const trajectories = await client.trajectories.list(filter);

  const actual = trajectories.items.map((traj) => traj.wellboreAssetExternalId);
  const expected = ["VOLVE:13/10-F-11 T2", "VOLVE:13/10-F-11 B"];
  const notExpected = ["VOLVE:11/5-F-5", "VOLVE:13/8-F-9 A"];

  const actualWellmatchIds = trajectories.items.map(
    (traj) => traj.wellboreMatchingId
  );
  const expectedWellmatches = ["13/10-F-11 T2"];

  expected.forEach((id) => expect(actual).toContain(id));
  notExpected.forEach((id) => expect(actual).not.toContain(id));
  expect(actualWellmatchIds).not.toContain("");
  expectContainAll(actualWellmatchIds, expectedWellmatches);
});

test("fetch data for a trajectory", async () => {
  expect(client).not.toBe(undefined);

  const actual: TrajectoryData = await client.trajectories.listData({
    sequenceExternalId: "13/10-F-11 T2 ACTUAL",
    measuredDepth: {
      min: 800.0,
      max: 1800.0,
      unit: "meter",
    },
  });
  expect(actual.equivalentDepartureUnit).toBe("meter");
  expect(actual.wellboreAssetExternalId).toBe("VOLVE:13/10-F-11 T2");
  expect(actual.wellboreMatchingId).toBe("13/10-F-11 T2");
  expect(actual.offsetUnit).toBe("meter");
  actual.rows.forEach((row) => {
    expect(row.measuredDepth).toBeGreaterThanOrEqual(800.0);
    expect(row.measuredDepth).toBeLessThanOrEqual(1800.0);
    expect(row.equivalentDeparture).toBeGreaterThanOrEqual(0.0);
    expect(row.eastOffset).toBeDefined();
    expect(row.northOffset).toBeDefined();
  });
});

test("interpolate trajectory", async () => {
  expect(client).not.toBe(undefined);
  const measuredDepths = [0, 10, 15, 20];
  const interpolationRequests: TrajectoryInterpolationRequest[] = [
    {
      wellboreId: {
        assetExternalId: "VOLVE:11/5-F-5",
      },
      measuredDepths: measuredDepths,
      measuredDepthUnit: { unit: "meter" },
    },
  ];
  const interpolationItems = await client.trajectories.interpolate({
    items: interpolationRequests,
  });
  expect(interpolationItems.items.length).not.toBe(0);
  const actual: TrueVerticalDepths = interpolationItems.items[0];
  expect(actual.trueVerticalDepthUnit.unit).toBe("meter");
  expect(actual.trueVerticalDepths).toHaveLength(4);
  expect(actual.measuredDepths).toEqual(measuredDepths);
  expect(actual.wellboreMatchingId).toBe("11/5-F-5");
});

test("interpolate trajectory with empty items list", async () => {
  expect(client).not.toBe(undefined);
  const interpolationItems = await client.trajectories.interpolate({
    items: [],
  });
  expect(interpolationItems.items.length).toBe(0);
});

test("list not definitive trajectories", async () => {
  const trajectories = await client.trajectories.list({
    filter: { isDefinitive: false },
  });
  const names = trajectories.items.map((x) => x.source.sequenceExternalId);
  expect(names).toStrictEqual(["15/9-F-15 D draft"]);
});

test("list definitive trajectories", async () => {
  const trajectories = await client.trajectories.list({
    filter: { isDefinitive: true },
  });
  const names = trajectories.items.map((x) => x.source.sequenceExternalId);
  expect(names).toContain("13/10-F-11 A curves");
  expect(names).not.toContain("15/9-F-15 D draft");
});