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

import type { ToolcraftImageAssetIngress } from "./types";
import { normalizeToolcraftImageAssetGeometry } from "./image-asset-geometry";

const canvasSize = { height: 720, unit: "px" as const, width: 1280 };
const sourceSize = { height: 300, unit: "px" as const, width: 400 };
const imageBase = {
  assetKind: "image" as const,
  fileName: "geometry.png",
  lifecycle: "ready" as const,
  mimeType: "image/png",
  resourceRef: "media://geometry",
};

function canonicalIngress(): ToolcraftImageAssetIngress {
  return {
    asset: {
      ...imageBase,
      position: { x: 14, y: -9 },
      size: { height: 90, unit: "px", width: 160 },
      sourceSize,
    },
    policy: "canonical-runtime",
  };
}

function preparedIngress(): ToolcraftImageAssetIngress {
  return {
    asset: {
      ...imageBase,
      position: { x: 45, y: 80 },
      sourceSize,
    },
    policy: "prepared-source",
  };
}

describe("normalizeToolcraftImageAssetGeometry", () => {
  it.each(["finite", "infinite"] as const)(
    "preserves canonical authored geometry in %s mode and clones it",
    (canvasMode) => {
      const ingress = canonicalIngress();
      const normalized = normalizeToolcraftImageAssetGeometry(ingress, {
        canvasMode,
        canvasSize,
        sizingMode: "editable-output",
      });

      expect(normalized).toEqual(ingress.asset);
      expect(normalized).not.toBe(ingress.asset);
      expect(normalized.position).not.toBe(ingress.asset.position);
      expect(normalized.size).not.toBe(ingress.asset.size);
      expect(normalized.sourceSize).not.toBe(ingress.asset.sourceSize);
    },
  );

  it("maps a prepared finite upload to the finite canvas scene frame", () => {
    expect(
      normalizeToolcraftImageAssetGeometry(preparedIngress(), {
        canvasMode: "finite",
        canvasSize,
        sizingMode: "editable-output",
      }),
    ).toEqual({
      ...imageBase,
      position: { x: 0, y: 0 },
      size: canvasSize,
      sourceSize,
    });
  });

  it("maps a prepared infinite upload to its decoded scene geometry", () => {
    expect(
      normalizeToolcraftImageAssetGeometry(preparedIngress(), {
        canvasMode: "infinite",
        canvasSize,
        sizingMode: "editable-output",
      }),
    ).toEqual({
      ...imageBase,
      position: { x: 45, y: 80 },
      size: sourceSize,
      sourceSize,
    });
  });

  it("preserves prepared intrinsic-media position and decoded scene geometry", () => {
    expect(
      normalizeToolcraftImageAssetGeometry(preparedIngress(), {
        canvasMode: "finite",
        canvasSize,
        sizingMode: "intrinsic-media",
      }),
    ).toEqual({
      ...imageBase,
      position: { x: 45, y: 80 },
      size: sourceSize,
      sourceSize,
    });
  });
});