import { expect, it } from "bun:test";
import { NoneMode, PluginSystem } from "../plugins/PluginSystem";
import {
  createCanvasPlugin,
  initialBaseCanvasData,
} from "../plugins/baseCanvas";
import { BaseContextProperties } from "../plugins/contextProperties";

it("should call handlers and finalizers in order", () => {
  type TestData = {
    handled: string[];
    finalized: string[];
  };

  interface TestContext extends BaseContextProperties<NoneMode, TestData> {}

  const pluginA = createCanvasPlugin({
    name: "a",
    data: {
      handled: [],
      finalized: [],
    },
    handlers: (context: TestContext) => ({
      onPointerDown: () => {
        context.setData((d) => ({ ...d, handled: [...d.handled, "a"] }));
      },
    }),
    finalizers: (context: TestContext) => ({
      onPointerDown: () => {
        context.setData((d) => ({ ...d, finalized: [...d.finalized, "a"] }));
      },
    }),
  });

  const pluginB = createCanvasPlugin({
    name: "b",
    data: {
      handled: [],
      finalized: [],
    },
    handlers: (context: TestContext) => ({
      onPointerDown: () => {
        context.setData((d) => ({ ...d, handled: [...d.handled, "b"] }));
      },
    }),
    finalizers: (context: TestContext) => ({
      onPointerDown: () => {
        context.setData((d) => ({ ...d, finalized: [...d.finalized, "b"] }));
      },
    }),
  });

  const pluginSystem = PluginSystem.create().addPlugins(pluginA, pluginB);

  let data: typeof pluginSystem.data = {
    ...initialBaseCanvasData,
    handled: [],
    finalized: [],
  };

  const context: typeof pluginSystem.contextProperties = {
    getMode: () => ({ type: "none" }),
    setMode: () => {},
    getData: () => data,
    setData: (d) => {
      if (typeof d === "function") {
        data = d(data);
      } else {
        data = d;
      }
    },
  };

  pluginSystem.callEventHandler(
    context,
    "onPointerDown",
    {} as React.PointerEvent
  );

  expect(data.handled).toEqual(["b", "a"]);
  expect(data.finalized).toEqual(["a", "b"]);
});