import { flattenDeep } from "lodash";
import Actor from "./actor";
import WorkerDispatch from "./worker-dispatch";
import { DemSource } from "./dem-source";
import { MainThreadDispatch } from "./remote-dem-manager";
import type { DemTile, Timing } from "./types";
import { VectorTile } from "@mapbox/vector-tile";
import Pbf from "pbf";
import { LocalDemManager } from "./local-dem-manager";

beforeEach(() => {
  jest.useFakeTimers({ now: 0, doNotFake: ["performance"] });
});
afterEach(() => {
  jest.useRealTimers();
});

jest.mock("./decode-image", () => (): Promise<DemTile> => {
  jest.advanceTimersByTime(1);
  // eslint-disable-next-line @typescript-eslint/no-require-imports
  const flattenDeep = require("lodash/flattenDeep");
  const value: DemTile = {
    data: Float32Array.from(
      flattenDeep([
        [5, 5, 5, 5],
        [5, 15, 15, 5],
        [5, 15, 15, 5],
        [5, 5, 5, 5],
      ]),
    ),
    width: 4,
    height: 4,
  };
  return Promise.resolve(value);
});

const remote = new WorkerDispatch();
const local = new MainThreadDispatch();
const workerFromMainThread: Worker = {} as any as Worker;
const mainThreadFromWorker: Worker = {} as any as Worker;
workerFromMainThread.postMessage = (data) =>
  mainThreadFromWorker?.onmessage?.({ data } as any);
mainThreadFromWorker.postMessage = (data) =>
  workerFromMainThread?.onmessage?.({ data } as any);
const mainActor = new Actor<WorkerDispatch>(workerFromMainThread, local);
const workerActor = new Actor<MainThreadDispatch>(mainThreadFromWorker, remote);

const source = new DemSource({
  url: "https://example/{z}/{x}/{y}.png",
  cacheSize: 100,
  encoding: "terrarium",
  maxzoom: 11,
  worker: true,
  actor: mainActor,
});

const expectedElevations = Float32Array.from(
  flattenDeep([
    [5, 5, 5, 5],
    [5, 15, 15, 5],
    [5, 15, 15, 5],
    [5, 5, 5, 5],
  ]),
);

test("e2e fetch tile and shared DEM protocol share cache", async () => {
  global.fetch = jest.fn().mockImplementation(async () => {
    jest.advanceTimersByTime(1);
    return new Response(
      new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
      {
        status: 200,
      },
    );
  });
  const tile = await source.getDemTile(1, 2, 3);
  expect(tile.data).toEqual(expectedElevations);
  expect(tile.width).toBe(4);
  expect(tile.height).toBe(4);
  const tile2 = await source.getDemTile(1, 2, 3);
  expect(tile2.data).toEqual(expectedElevations);

  const timings: Timing[] = [];
  source.onTiming((timing) => timings.push(timing));
  const fetched = (
    await source.sharedDemProtocol(
      {
        url: source.sharedDemProtocolUrl
          .replace("{z}", "1")
          .replace("{x}", "2")
          .replace("{y}", "3"),
      },
      new AbortController(),
    )
  ).data;

  expect(fetched).toEqual(Uint8Array.from([1, 2]).buffer);

  expect(global.fetch).toBeCalledTimes(1);
  expect(global.fetch).toBeCalledWith(
    "https://example/1/2/3.png",
    expect.anything(),
  );
  expect(timings).toMatchObject([
    {
      duration: 0,
      marks: {
        main: [[2, 2]],
        worker: [[2, 2]],
      },
      resources: [],
      url: "dem-shared://1/2/3",
      wait: 0,
    },
  ]);
});

test("e2e contour tile", async () => {
  global.fetch = jest.fn().mockImplementation(async () => {
    jest.advanceTimersByTime(1);
    return new Response(
      new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
      {
        status: 200,
      },
    );
  });
  const timings: Timing[] = [];
  source.onTiming((timing) => timings.push(timing));
  const contourTile: ArrayBuffer = (
    await source.contourProtocol(
      {
        url: source
          .contourProtocolUrl({
            thresholds: {
              10: 10,
            },
            buffer: 0,
            contourLayer: "c",
            elevationKey: "e",
            levelKey: "l",
            overzoom: 0,
          })
          .replace("{z}", "10")
          .replace("{x}", "20")
          .replace("{y}", "30"),
      },
      new AbortController(),
    )
  ).data;

  const tile = new VectorTile(new Pbf(contourTile));

  expect(tile.layers.c.name).toBe("c");
  expect(tile.layers.c.extent).toBe(4096);
  expect(tile.layers.c.length).toBe(1);
  expect(tile.layers.c.feature(0).properties).toEqual({
    e: 10,
    l: 0,
  });
  const geom = tile.layers.c.feature(0).loadGeometry()[0];
  expect(geom.length).toEqual(253);

  let xSum = 0,
    ySum = 0;
  for (const { x, y } of geom) {
    xSum += x;
    ySum += y;
  }
  const center = { x: Math.round(xSum / 253), y: Math.round(ySum / 253) };
  expect(center).toMatchObject({
    x: 2049,
    y: 2052,
  });
  expect(timings).toMatchObject([
    {
      tilesUsed: 9,
      process: 0,
      duration: 18,
      marks: {
        main: [[0, 18]],
        worker: [[0, 18]],
        fetch: [
          [0, 9],
          [1, 9],
          [2, 9],
          [3, 9],
          [4, 9],
          [5, 9],
          [6, 9],
          [7, 9],
          [8, 9],
        ],
        decode: [
          [10, 18],
          [11, 18],
          [12, 18],
          [13, 18],
          [14, 18],
          [15, 18],
          [16, 18],
          [17, 18],
          [18, 18],
        ],
        isoline: [[18, 18, 18]],
      },
      decode: 8,
      fetch: 9,
      resources: [],
      url: "dem-contour://10/20/30?buffer=0&contourLayer=c&elevationKey=e&levelKey=l&overzoom=0&thresholds=10*10",
      wait: 1,
    },
  ]);

  // fetch adjacent tile where 6/9 neighbors are already cached
  jest.setSystemTime(1);
  performance.getEntriesByName = (name) => [
    {
      duration: 1,
      name,
      entryType: "resource",
      startTime: performance.now(),
    } as PerformanceResourceTiming,
  ];
  await source.contourProtocol(
    {
      url: source
        .contourProtocolUrl({
          thresholds: {
            10: 10,
          },
          overzoom: 0,
        })
        .replace("{z}", "10")
        .replace("{x}", "21")
        .replace("{y}", "30"),
    },
    new AbortController(),
  );
  expect(timings[1]).toMatchObject({
    tilesUsed: 9,
    process: 0,
    duration: 6,
    decode: 2,
    fetch: 3,
    wait: 1,
    marks: {
      main: [[1, 7]],
      worker: [[1, 7]],
      fetch: [
        [1, 4],
        [2, 4],
        [3, 4],
      ],
      decode: [
        [5, 7],
        [6, 7],
        [7, 7],
      ],
      isoline: [[7, 7, 7]],
    },
    resources: [
      { duration: 1, startTime: 7, name: "https://example/10/22/29.png" },
      { duration: 1, startTime: 7, name: "https://example/10/22/30.png" },
      { duration: 1, startTime: 7, name: "https://example/10/22/31.png" },
    ],
    url: "dem-contour://10/21/30?overzoom=0&thresholds=10*10",
  });
});

test("decode image from worker", async () => {
  const result = await workerActor.send(
    "decodeImage",
    [],
    new AbortController(),
    undefined,
    new Blob([], { type: "image/png" }),
    "terrarium",
  );
  expect(result).toMatchObject({
    width: 4,
    height: 4,
    data: expectedElevations,
  });
});

test("fake decode image and fetch tile", async () => {
  const getTileSpy = jest.fn().mockReturnValue(Promise.resolve({}));
  const demManager = new LocalDemManager({
    demUrlPattern: "https://example/{z}/{x}/{y}.png",
    cacheSize: 100,
    encoding: "terrarium",
    maxzoom: 11,
    timeoutMs: 10000,
    decodeImage: async () => ({
      width: 4,
      height: 4,
      data: expectedElevations,
    }),
    getTile: getTileSpy,
  });
  const demTile = await demManager.fetchAndParseTile(
    1,
    2,
    3,
    new AbortController(),
  );
  expect(demTile.data).toEqual(expectedElevations);
  expect(getTileSpy.mock.calls[0][0]).toBe("https://example/1/2/3.png");
});