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

import { defineToolcraft } from "./define-toolcraft";

describe("defineToolcraft canvas defaults", () => {
  it("defaults enabled canvas to draggable with canvas toolbar features", () => {
    const app = defineToolcraft({
      canvas: { enabled: true },
      panels: {},
    });

    expect(app.canvas.draggable).toBe(true);
    expect(app.canvas.size).toEqual({ height: 1080, unit: "px", width: 1920 });
    expect(app.canvas.sizeSource).toBe("runtime-default");
    expect(app.canvas.sizing).toEqual({ mode: "intrinsic-media" });
    expect(app.toolbar).toEqual({ history: true, radar: true, theme: true, zoom: true });
  });

  it("defaults upload canvases to editable output unless intrinsic media is explicit", () => {
    const app = defineToolcraft({
      canvas: { enabled: true, upload: true },
      panels: {},
    });

    expect(app.canvas.size).toEqual({ height: 1080, unit: "px", width: 1920 });
    expect(app.canvas.sizeSource).toBe("runtime-default");
    expect(app.canvas.sizing).toEqual({ mode: "editable-output" });
    expect(app.assembly.capabilities).toContain("canvas.editableSize");
    expect(app.assembly.commands).toContain("canvas.setSize");
  });

  it("preserves explicit intrinsic media sizing for source-native upload apps", () => {
    const app = defineToolcraft({
      canvas: { enabled: true, sizing: { mode: "intrinsic-media" }, upload: true },
      panels: {},
    });

    expect(app.canvas.sizing).toEqual({ mode: "intrinsic-media" });
    expect(app.assembly.capabilities).not.toContain("canvas.editableSize");
    expect(app.assembly.commands).not.toContain("canvas.setSize");
  });

  it("defaults explicit canvas size to editable output", () => {
    const size = { width: 1365, height: 768, unit: "px" } as const;

    const app = defineToolcraft({
      canvas: { enabled: true, size },
      panels: {
        controls: {
          sections: [],
          title: "Controls",
        },
      },
    });

    expect(app.canvas.size).toBe(size);
    expect(app.canvas.size).toEqual({ width: 1365, height: 768, unit: "px" });
    expect(app.canvas.sizeSource).toBe("app");
    expect(app.canvas.sizing).toEqual({ mode: "editable-output" });
    expect(app.panels.controls?.sections[0]?.title).toBe("Setup");
    expect(app.panels.controls?.sections[0]?.controls.canvasAspectRatio).toMatchObject({
      defaultValue: {
        height: 256,
        mode: "custom",
        value: "455:256",
        width: 455,
      },
      label: "Aspect ratio",
      performanceRole: "workload",
      target: "canvas.aspectRatio",
      type: "aspectRatio",
    });
    expect(app.panels.controls?.sections[0]?.controls.canvasWidth).toMatchObject({
      defaultValue: 1365,
      performanceRole: "workload",
      target: "canvas.size.width",
    });
    expect(app.panels.controls?.sections[0]?.controls.canvasHeight).toMatchObject({
      defaultValue: 768,
      performanceRole: "workload",
      target: "canvas.size.height",
    });
  });

  it("preserves app-chosen canvas widths below the app shell minimum", () => {
    const app = defineToolcraft({
      canvas: { enabled: true, size: { width: 640, height: 768, unit: "px" } },
      panels: {},
    });

    expect(app.canvas.size).toEqual({ width: 640, height: 768, unit: "px" });
    expect(app.canvas.sizeSource).toBe("app");
  });

  it("does not prepend canvas size controls for intrinsic media or explicitly fixed output", () => {
    const intrinsicApp = defineToolcraft({
      canvas: {
        enabled: true,
        sizing: { mode: "intrinsic-media" },
        upload: true,
      },
      panels: {
        controls: {
          sections: [
            {
              controls: {
                prompt: {
                  target: "generation.prompt",
                  type: "text",
                },
              },
              title: "Generation",
            },
          ],
          title: "Controls",
        },
      },
    });
    const fixedApp = defineToolcraft({
      canvas: {
        enabled: true,
        size: { height: 900, unit: "px", width: 1440 },
        sizing: { mode: "fixed-output" },
      },
      panels: intrinsicApp.panels,
    });

    expect(intrinsicApp.canvas.sizing).toEqual({ mode: "intrinsic-media" });
    expect(fixedApp.canvas.sizing).toEqual({ mode: "fixed-output" });
    expect(intrinsicApp.panels.controls?.sections[0]?.title).toBe("Setup");
    expect(fixedApp.panels.controls?.sections[0]?.title).toBe("Setup");
    expect(intrinsicApp.panels.controls?.sections[1]?.title).toBe("Generation");
    expect(fixedApp.panels.controls?.sections.at(-1)?.title).toBe("Generation");
    expect(intrinsicApp.panels.controls?.sections[0]?.controls.canvasWidth).toBeUndefined();
    expect(fixedApp.panels.controls?.sections[0]?.controls.canvasWidth).toBeUndefined();
    expect(intrinsicApp.panels.controls?.sections[0]?.controls.settingsTransfer).toBeTruthy();
    expect(fixedApp.panels.controls?.sections[0]?.controls.settingsTransfer).toBeTruthy();
  });

  it("forces disabled canvas to non-draggable while preserving explicit toolbar choices", () => {
    const app = defineToolcraft({
      canvas: { draggable: true, enabled: false },
      panels: {},
      toolbar: { history: true },
    });

    expect(app.canvas.draggable).toBe(false);
    expect(app.toolbar).toEqual({ history: true, radar: false, theme: true, zoom: false });
  });
});