import { describe, expect, it, vi } from "vitest";
import { createHydrationModelAsset } from "../../model-import/model-persistence-hydration-test-support";
import { defineToolcraft } from "../../schema/define-toolcraft";
import { createToolcraftState } from "../../state/create-template-state";
import { renderToolcraftRuntimeSceneToCanvas } from "./runtime-scene-export";
import { createContext, createHost } from "./runtime-scene-export.test-support";

describe("runtime scene export visibility", () => {
  it("honors one visibility snapshot for default images and custom models", async () => {
    const state = createToolcraftState(
      defineToolcraft({
        base: {
          identity: { id: "runtime-test", title: "Toolcraft App" },
          canvas: { enabled: true },
          panels: {},
        },
        modules: [],
      }),
      {
        canvas: { mode: "infinite" },
        mediaAssets: [
          createHydrationModelAsset("document:model", {
            lifecycle: "clean",
            sourceTarget: "source.model",
          }),
        ],
      },
    );
    const context = createContext([]);
    const canvas = {
      getContext: vi.fn(() => context),
      height: 100,
      width: 100,
    } as unknown as HTMLCanvasElement;
    const loadImage = vi.fn();
    const host = createHost({ kind: "model" } as unknown as HTMLCanvasElement);
    await expect(
      renderToolcraftRuntimeSceneToCanvas({
        signal: new AbortController().signal,
        canvas,
        host,
        loadImage,
        outputFrame: { height: 100, width: 100, x: 0, y: 0 },
        state,
        visibility: {
          renderDefaultImages: false,
          suppressedModelTargets: ["source.model"],
        },
      }),
    ).resolves.toEqual({ imageCount: 0, modelCount: 0 });
    expect(host.renderExport).not.toHaveBeenCalled();
    expect(loadImage).not.toHaveBeenCalled();
  });
  it("excludes unavailable images before resolving export resources", async () => {
    const resourceRef = `media:image:sha256:${"b".repeat(64)}`;
    const state = createToolcraftState(
      defineToolcraft({
        base: {
          identity: { id: "runtime-test", title: "Toolcraft App" },
          canvas: { enabled: true },
          panels: {},
        },
        modules: [],
      }),
      {
        mediaAssets: [
          {
            assetKind: "image",
            error: {
              code: "binary-resource-unavailable",
              message: "The image resource is unavailable.",
            },
            fileName: "unavailable.png",
            id: "unavailable-image",
            layerId: "unavailable-layer",
            lifecycle: "unavailable",
            mimeType: "image/png",
            position: { x: 0, y: 0 },
            resourceRef,
            size: { height: 20, unit: "px", width: 20 },
            sourceSize: { height: 20, unit: "px", width: 20 },
          },
        ],
      },
    );
    const context = createContext([]);
    const canvas = {
      getContext: vi.fn(() => context),
      height: 100,
      width: 100,
    } as unknown as HTMLCanvasElement;
    const loadImage = vi.fn();
    await expect(
      renderToolcraftRuntimeSceneToCanvas({
        signal: new AbortController().signal,
        canvas,
        host: null,
        outputFrame: { height: 100, width: 100, x: 0, y: 0 },
        loadImage,
        state,
        visibility: {
          renderDefaultImages: true,
          suppressedModelTargets: [],
        },
      }),
    ).resolves.toEqual({ imageCount: 0, modelCount: 0 });
    expect(loadImage).not.toHaveBeenCalled();
    expect(context.drawImage).not.toHaveBeenCalled();
  });
});