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

import { defineToolcraft } from "../schema/define-toolcraft";
import { createToolcraftState } from "../state/create-template-state";
import { toolcraftReducer } from "../state/reducer";
import {
  createToolcraftDefaultBinaryMediaHydrationJobs,
} from "./binary-media-hydration";
import { createMemoryToolcraftBinaryAssetRepository } from "./repository/memory-binary-asset-repository";
import { createToolcraftSourceAssetCoordinator } from "./source-asset-coordinator";

describe("default binary media hydration", () => {
  it("restores a reset default from the same durable resource", async () => {
    const schema = defineToolcraft({
      canvas: { enabled: true },
      media: {
        defaultAssets: [
          {
            dataUrl: "data:image/png;base64,AQID",
            fileName: "default.png",
            id: "default-image",
            layerId: "default-layer",
            mimeType: "image/png",
            sourceTarget: "source.image",
          },
        ],
      },
      panels: {
        controls: {
          sections: [
            {
              controls: {
                source: {
                  defaultValue: null,
                  target: "source.image",
                  type: "fileDrop",
                },
              },
            },
          ],
          title: "Controls",
        },
      },
    });
    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();
  });
});