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

import { mediaSourceModule } from "../modules/built-ins/media-source/media-source-module";
import { defineToolcraft } from "./define-toolcraft";

describe("defineToolcraft canvas defaults", () => {
  it("defaults enabled canvas to draggable with canvas toolbar features", () => {
    const app = defineToolcraft({
      base: {
        identity: { id: "runtime-test", title: "Toolcraft App" },
        canvas: { enabled: true },
        panels: {},
      },
      modules: [],
    });

    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({
      base: {
        identity: { id: "runtime-test", title: "Toolcraft App" },
        canvas: { enabled: true, upload: true },
        panels: {},
      },
      modules: [mediaSourceModule()],
    });

    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({
      base: {
        identity: { id: "runtime-test", title: "Toolcraft App" },
        canvas: {
          enabled: true,
          sizing: { mode: "intrinsic-media" },
          upload: true,
        },
        panels: {},
      },
      modules: [mediaSourceModule()],
    });

    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({
      base: {
        identity: { id: "runtime-test", title: "Toolcraft App" },
        canvas: { enabled: true, size },
        panels: {
          controls: {
            sections: [],
            title: "Controls",
          },
        },
      },
      modules: [],
    });

    expect(app.canvas.size).not.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[1]?.title).toBe("Settings");
    expect(
      app.panels.controls?.sections[1]?.controls.canvasAspectRatio,
    ).toMatchObject({
      applicability: { mode: "conditional" as const },
      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[1]?.controls.canvasWidth,
    ).toMatchObject({
      defaultValue: 1365,
      performanceRole: "workload",
      target: "canvas.size.width",
    });
    expect(
      app.panels.controls?.sections[1]?.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({
      base: {
        identity: { id: "runtime-test", title: "Toolcraft App" },
        canvas: {
          enabled: true,
          size: { width: 640, height: 768, unit: "px" },
        },
        panels: {},
      },
      modules: [],
    });

    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 controls = {
      sections: [
        {
          id: "test-section-1",
          controls: {
            prompt: {
              applicability: { mode: "always" as const },
              target: "generation.prompt",
              type: "text" as const,
            },
          },
          title: "Generation",
        },
      ],
      title: "Controls",
    };
    const intrinsicApp = defineToolcraft({
      base: {
        identity: { id: "runtime-test", title: "Toolcraft App" },
        canvas: {
          enabled: true,
          sizing: { mode: "intrinsic-media" },
          upload: true,
        },
        panels: { controls },
      },
      modules: [mediaSourceModule()],
    });
    const fixedApp = defineToolcraft({
      base: {
        identity: { id: "runtime-test", title: "Toolcraft App" },
        canvas: {
          enabled: true,
          size: { height: 900, unit: "px", width: 1440 },
          sizing: { mode: "fixed-output" },
        },
        panels: { controls },
      },
      modules: [],
    });

    expect(intrinsicApp.canvas.sizing).toEqual({ mode: "intrinsic-media" });
    expect(fixedApp.canvas.sizing).toEqual({ mode: "fixed-output" });
    expect(intrinsicApp.panels.controls?.sections[1]?.title).toBe("Settings");
    expect(fixedApp.panels.controls?.sections[1]?.title).toBe("Settings");
    expect(intrinsicApp.panels.controls?.sections[2]?.title).toBe("Generation");
    expect(fixedApp.panels.controls?.sections.at(-1)?.title).toBe("Generation");
    expect(
      intrinsicApp.panels.controls?.sections[1]?.controls.canvasWidth,
    ).toBeUndefined();
    expect(
      fixedApp.panels.controls?.sections[1]?.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({
      base: {
        identity: { id: "runtime-test", title: "Toolcraft App" },
        canvas: { draggable: true, enabled: false },
        panels: {},
        toolbar: { history: true },
      },
      modules: [],
    });

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