import type { ImageDocument } from "@core/document";
import type { Rect } from "@core/geometry";
import type { LayerId } from "@core/id";
import type { Layer } from "@core/layer";
import { getLayerMask } from "@core/layer-mask-utils";
import { resolveTransformTargetBounds } from "@editor/transform-targets";
import type { TransformTarget } from "@editor/transform";

export function applyTransformTargetBounds(document: ImageDocument, target: TransformTarget, bounds: Rect): ImageDocument {
  if (target.type === "artboard") return { ...document, artboards: document.artboards.map((artboard) => artboard.id === target.id ? { ...artboard, bounds: { ...bounds } } : artboard) };
  const layer = findLayer(document, target.id);
  if (!layer) return document;
  return layer.type === "group" ? applyGroupBounds(document, layer.id, bounds) : layer.type === "adjustment" ? document : applyLeafBounds(document, layer.id, bounds);
}

function applyLeafBounds(document: ImageDocument, layerId: LayerId, bounds: Rect): ImageDocument {
  const layer = findLayer(document, layerId);
  if (!layer) return document;
  const mask = getLayerMask(layer);
  return [layerId, ...(mask ? [mask.maskLayerId] : [])].reduce((next, id) => ({
    ...next,
    artboards: next.artboards.map((artboard) => ({ ...artboard, layers: mapLeafBounds(next, artboard.layers, id, bounds) })),
  }), document);
}

function applyGroupBounds(document: ImageDocument, groupId: LayerId, bounds: Rect): ImageDocument {
  const initial = resolveTransformTargetBounds(document, { type: "layer", id: groupId });
  if (!initial || initial.w === 0 || initial.h === 0) return document;
  const scale = { x: bounds.w / initial.w, y: bounds.h / initial.h };
  return { ...document, artboards: document.artboards.map((artboard) => ({ ...artboard, layers: mapGroupBounds(document, artboard.layers, groupId, initial, bounds, scale) })) };
}

function mapGroupBounds(document: ImageDocument, layers: Layer[], groupId: LayerId, initial: Rect, bounds: Rect, scale: { x: number; y: number }): Layer[] {
  return layers.map((layer) => {
    if (layer.type === "group" && layer.id === groupId) return { ...layer, children: layer.children.map((child) => scaleSubtree(document, child, initial, bounds, scale)) };
    return layer.type === "group" ? { ...layer, children: mapGroupBounds(document, layer.children, groupId, initial, bounds, scale) } : layer;
  });
}

function scaleSubtree(document: ImageDocument, layer: Layer, initial: Rect, bounds: Rect, scale: { x: number; y: number }): Layer {
  if (layer.type === "group") return { ...layer, children: layer.children.map((child) => scaleSubtree(document, child, initial, bounds, scale)) };
  if (layer.type === "adjustment") return layer;
  if (!document.assets.some((asset) => asset.id === layer.assetId)) return layer;
  return { ...layer, transform: { ...layer.transform, position: { x: bounds.x + (layer.transform.position.x - initial.x) * scale.x, y: bounds.y + (layer.transform.position.y - initial.y) * scale.y }, scale: { x: layer.transform.scale.x * scale.x, y: layer.transform.scale.y * scale.y } } };
}

function mapLeafBounds(document: ImageDocument, layers: Layer[], layerId: LayerId, bounds: Rect): Layer[] {
  return layers.map((layer) => {
    if (layer.id === layerId && layer.type !== "group" && layer.type !== "adjustment") {
      const asset = document.assets.find((candidate) => candidate.id === layer.assetId);
      if (!asset) return layer;
      const source = layer.sourceRect ?? { x: 0, y: 0, ...asset.intrinsicSize };
      const scale = { x: bounds.w / source.w, y: bounds.h / source.h };
      return { ...layer, transform: { ...layer.transform, position: { x: bounds.x - source.x * scale.x, y: bounds.y - source.y * scale.y }, scale } };
    }
    return layer.type === "group" ? { ...layer, children: mapLeafBounds(document, layer.children, layerId, bounds) } : layer;
  });
}

function findLayer(document: ImageDocument, layerId: LayerId): Layer | undefined {
  const visit = (layers: readonly Layer[]): Layer | undefined => {
    for (const layer of layers) {
      if (layer.id === layerId) return layer;
      if (layer.type === "group") { const child = visit(layer.children); if (child) return child; }
    }
  };
  for (const artboard of document.artboards) { const layer = visit(artboard.layers); if (layer) return layer; }
}