import { CogniteWellsClient, DepthMeasurementData } from "src";
import { setupLoggedInClient } from "../testUtils";
import { DepthMeasurementFilterRequest } from "src/model/depthMeasurementFilterRequest";
import { SequenceExternalId } from "src/model/sequenceExternalId";

export enum DistanceUnitEnum {
  METER = "meter",
  FOOT = "foot",
  INCH = "inch",
  YARD = "yard",
}

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

test("fetch measurements by multiple wellbores", async () => {
  expect(client).not.toBe(undefined);

  const filter: DepthMeasurementFilterRequest = {
    filter: {
      wellboreIds: [{ assetExternalId: "VOLVE:15/9-F-15 A" }],
    },
  };

  await client.measurements.list(filter);
});

test("fetch measurements for a non existent wellbores", async () => {
  expect(client).not.toBe(undefined);
  const filter: DepthMeasurementFilterRequest = {
    filter: {
      wellboreIds: [{ assetExternalId: "NON-EXISTENT" }],
    },
  };
  client.measurements.list(filter).catch((err) => {
    expect(err.status).toBe(400);
  });
});

test("get measurements by ids", async () => {
  expect(client).not.toBe(undefined);
  const id = "VOLVE:seq1";
  const sequenceId: SequenceExternalId = {
    sequenceExternalId: id,
  };
  const measurements = await client.measurements.retrieveMultiple({
    items: [sequenceId],
  });
  expect(measurements.items.length).toBe(1);
  const measurement = measurements.items[0];
  expect(measurement.source.sequenceExternalId).toBe(id);
});

test("get measurements by hole sections", async () => {
  expect(client).not.toBe(undefined);
  const filter: DepthMeasurementFilterRequest = {
    filter: {
      holeSections: {
        bitSize: {
          value: 8,
          unit: DistanceUnitEnum.INCH,
        },
        holeSize: {
          value: 8.5,
          unit: DistanceUnitEnum.INCH,
        },
      },
    },
  };
  const measurements = await client.measurements.list(filter);
  expect(measurements).not.toBeUndefined();
  expect(measurements.items.length).toBeGreaterThan(0);
});

test("get measurements by well tops", async () => {
  expect(client).not.toBe(undefined);
  client.experimental.enable();
  const filter: DepthMeasurementFilterRequest = {
    filter: {
      wellTops: {
        surfaceNames: {
          containsAny: ["Seabed", "NORDLAND GP."],
        },
      },
    },
  };
  const measurements = await client.measurements.list(filter);
  expect(measurements).not.toBeUndefined();
  expect(measurements.items.length).toBeGreaterThan(0);
});

test("fetch data for a measurement", async () => {
  const data: DepthMeasurementData = await client.measurements.listData({
    sequenceExternalId: "VOLVE:seq1",
  });
  expect(data.rows.length).not.toBe(0);
});

test("fetch data for a measurement by columns", async () => {
  const data: DepthMeasurementData = await client.measurements.listData({
    sequenceExternalId: "VOLVE:seq1",
    columnExternalIds: ["RMED"],
    limit: 1,
  });
  expect(data.rows.length).not.toBe(0);
  const columnsNames = data.columns.map((column) => column.externalId);
  expect(columnsNames).toEqual(["RMED"]);
});