import { describe, expect, it } from "vitest";

import { mediaSourceModule } from "../modules/built-ins/media-source/media-source-module";
import { defineToolcraft } from "../schema/define-toolcraft";
import { createToolcraftState } from "../state/create-template-state";
import { toolcraftReducer } from "../composition/public-state";
import { createToolcraftDefaultBinaryMediaHydrationJobs } from "./binary-media-hydration";
import { createMemoryToolcraftBinaryAssetRepository } from "./repository/memory-binary-asset-repository";
import { createToolcraftSourceAssetCoordinator } from "../composition/source-asset-coordinator";

describe("default binary media hydration", () => {
  it("restores a reset default from the same durable resource", async () => {
    const schema = defineToolcraft({
      base: {
        identity: { id: "runtime-test", title: "Toolcraft App" },
        canvas: { enabled: true },
        media: {
          defaultAssets: [
            {
              ingressPolicy: "prepared-source",
              position: { x: 0, y: 0 },
              sourceSize: { height: 512, unit: "px", width: 512 },
              dataUrl: "data:image/png;base64,AQID",
              fileName: "default.png",
              id: "default-image",
              layerId: "default-layer",
              mimeType: "image/png",
              sourceTarget: "source.image",
            },
          ],
        },
        panels: {
          controls: {
            sections: [
              {
                id: "test-section-1",
                controls: {
                  source: {
                    applicability: { mode: "always" as const },
                    defaultValue: null,
                    target: "source.image",
                    type: "fileDrop",
                  },
                },
              },
            ],
            title: "Controls",
          },
        },
      },
      modules: [mediaSourceModule()],
    });
    let state = createToolcraftState(schema);
    const repository = createMemoryToolcraftBinaryAssetRepository();
    const coordinator = createToolcraftSourceAssetCoordinator({
      dispatch: (command) => {
        state = toolcraftReducer(state, command);
      },
      getState: () => state,
      repository,
    });
    const jobs = createToolcraftDefaultBinaryMediaHydrationJobs(schema);
    const resourceRef =
      state.mediaAssets[0]?.assetKind === "image"
        ? state.mediaAssets[0].resourceRef
        : undefined;

    expect(resourceRef).toMatch(/^media:image:sha256:/u);
    expect(state.mediaAssets[0]).toMatchObject({ lifecycle: "restoring" });
    expect(state.mediaAssets[0]).not.toHaveProperty("dataUrl");

    await coordinator.hydrateBinaryMedia(jobs);

    expect(state.mediaAssets[0]).toMatchObject({
      lifecycle: "ready",
      resourceRef,
    });
    await expect(repository.get(resourceRef!)).resolves.toMatchObject({
      bytes: new Uint8Array([1, 2, 3]),
      durable: true,
    });

    state = toolcraftReducer(state, {
      mediaId: "default-image",
      type: "media.delete",
    });
    state = toolcraftReducer(state, { type: "controls.reset" });

    expect(state.mediaAssets[0]).toMatchObject({
      lifecycle: "restoring",
      resourceRef,
    });
    await coordinator.hydrateBinaryMedia(jobs);
    expect(state.mediaAssets[0]).toMatchObject({
      lifecycle: "ready",
      resourceRef,
    });

    await coordinator.dispose();
  });
});