feuerwerk/src/editor/inspector/songSection.ts

import { SetSongCommand } from '../../core/commands/songCommands';
import type { SongAsset } from '../../core/model/Asset';
import { ASSET_TYPE_LABELS } from '../../core/model/AssetTypes';
import { findAsset, findAssetOf, type Project } from '../../core/model/Project';
import type { PropertyDef } from '../../core/properties/PropertySchema';
import {
  ITEM_MIN_DB,
  itemMaxDb,
  MAX_TRANSPOSE,
  type SongItem,
  type SongTrack,
  TRACK_MAX_DB,
  TRACK_MIN_DB,
} from '../../core/music/song';
import { createFieldRow } from './fieldFactory';
import { addNameField, addNote, addTitle, type InspectorHost } from './host';
import { previewingHandlers } from './previewHandlers';

const TRACK_ROWS: readonly PropertyDef[] = [
  {
    key: 'volume',
    label: 'Volume (dB)',
    kind: 'number',
    default: 0,
    min: TRACK_MIN_DB,
    max: TRACK_MAX_DB,
    step: 0.5,
  },
  { key: 'pan', label: 'Pan', kind: 'number', default: 0, min: -1, max: 1, step: 0.05 },
  { key: 'mute', label: 'Mute', kind: 'boolean', default: false },
  { key: 'solo', label: 'Solo', kind: 'boolean', default: false },
];

/** The rows of an item: what it plays, how loud, and per kind how. */
function itemRows(item: SongItem): PropertyDef[] {
  const rows: PropertyDef[] = [
    {
      key: 'asset',
      label: ASSET_TYPE_LABELS[item.kind],
      kind: 'asset',
      default: '',
      assetTypes: [item.kind],
    },
    {
      key: 'volume',
      label: 'Volume (dB)',
      kind: 'number',
      default: 0,
      min: ITEM_MIN_DB,
      max: itemMaxDb(item.kind),
      step: 0.5,
    },
  ];
  if (item.kind === 'pattern')
    rows.push(
      {
        key: 'transpose',
        label: 'Transpose',
        kind: 'number',
        default: 0,
        min: -MAX_TRANSPOSE,
        max: MAX_TRANSPOSE,
        step: 1,
        decimals: 0,
      },
      { key: 'instrument', label: 'Instrument', kind: 'asset', default: '', assetTypes: ['instrument'] },
    );
  else rows.push({ key: 'fx', label: 'Sound FX', kind: 'asset', default: '', assetTypes: ['soundfx'] });
  return rows;
}

/** What decides the rows: whether it is the track or an item, and of what kind. */
export function songSignature(
  project: Project,
  assetId: string,
  trackId: string,
  itemIds: readonly string[],
): string {
  const asset = findAssetOf(project, assetId, 'song');
  const item = itemOf(asset, itemIds);
  if (item) return `item:${item.id}:${item.kind}`;
  return asset?.tracks.some((t) => t.id === trackId) ? `track:${trackId}` : 'missing';
}

/** The item picked last (#334), else the track: its rows. */
export function buildSongSection(
  host: InspectorHost,
  assetId: string,
  trackId: string,
  itemIds: readonly string[],
): void {
  const asset = findAssetOf(host.state.project, assetId, 'song');
  if (!asset) return;
  const item = itemOf(asset, itemIds);
  if (item) return buildItem(host, asset, item, itemIds.length);
  const track = asset.tracks.find((t) => t.id === trackId);
  if (track) buildTrack(host, asset, track);
}

export function refreshSongSection(
  host: InspectorHost,
  assetId: string,
  trackId: string,
  itemIds: readonly string[],
): boolean {
  const asset = findAssetOf(host.state.project, assetId, 'song');
  const item = itemOf(asset, itemIds);
  if (item) {
    for (const def of itemRows(item)) host.fields.get(def.key)?.setValue(item[def.key as keyof SongItem]);
    return true;
  }
  const track = asset?.tracks.find((t) => t.id === trackId);
  if (!track) return false;
  host.nameField?.setValue(track.name);
  for (const def of TRACK_ROWS) host.fields.get(def.key)?.setValue(track[def.key as keyof SongTrack]);
  return true;
}

function buildTrack(host: InspectorHost, asset: SongAsset, track: SongTrack): void {
  const { state } = host;
  addTitle(host, 'SONG TRACK');
  addNameField(host, track.name, {
    onChange: (name) => {
      if (name.trim())
        state.execute(
          new SetSongCommand(
            asset.id,
            { tracks: withTrack(state.project, asset.id, track.id, { name: name.trim() }) },
            'Rename track',
          ),
        );
      else host.nameField?.setValue(track.name);
    },
  });
  const count = asset.items.filter((i) => i.track === track.id).length;
  addNote(host, `Track of the song "${asset.name}", ${count} ${count === 1 ? 'item' : 'items'}.`);
  for (const def of TRACK_ROWS) {
    const handlers = previewingHandlers<SongTrack, SongTrack[keyof SongTrack]>(host, {
      target: () => findAssetOf(state.project, asset.id, 'song')?.tracks.find((t) => t.id === track.id),
      read: (target) => target[def.key as keyof SongTrack],
      write: (target, value) => Object.assign(target, { [def.key]: value }),
      commit: (value) =>
        new SetSongCommand(
          asset.id,
          { tracks: withTrack(state.project, asset.id, track.id, { [def.key]: value }) },
          `Set track ${def.key}`,
        ),
    });
    const row = createFieldRow(host, def, track[def.key as keyof SongTrack], handlers);
    host.fields.set(def.key, row);
    host.body.add(row.row);
  }
}

function buildItem(host: InspectorHost, asset: SongAsset, item: SongItem, picked: number): void {
  const { state } = host;
  addTitle(host, 'SONG ITEM');
  const track = asset.tracks.find((t) => t.id === item.track);
  const what = findAsset(state.project, item.asset)?.name ?? 'missing';
  const others = picked > 1 ? ` ${picked - 1} more picked.` : '';
  addNote(host, `${ASSET_TYPE_LABELS[item.kind]} "${what}" on ${track?.name ?? 'a track'}.${others}`);
  for (const def of itemRows(item)) {
    const handlers = previewingHandlers<SongItem, SongItem[keyof SongItem]>(host, {
      target: () => findAssetOf(state.project, asset.id, 'song')?.items.find((i) => i.id === item.id),
      read: (target) => target[def.key as keyof SongItem],
      write: (target, value) => Object.assign(target, { [def.key]: value }),
      commit: (value) =>
        new SetSongCommand(
          asset.id,
          { items: withItem(state.project, asset.id, item.id, { [def.key]: value }) },
          `Set item ${def.key}`,
        ),
    });
    const row = createFieldRow(host, def, item[def.key as keyof SongItem], handlers);
    host.fields.set(def.key, row);
    host.body.add(row.row);
  }
  if (item.kind === 'pattern') addNote(host, 'An empty Instrument plays the pattern with its own.', 'small');
}

function itemOf(asset: SongAsset | undefined, itemIds: readonly string[]): SongItem | undefined {
  const id = itemIds.at(-1);
  return id === undefined ? undefined : asset?.items.find((i) => i.id === id);
}

/** The tracks with one of them changed, read at that moment so another edit in between stays. */
function withTrack(
  project: Project,
  assetId: string,
  trackId: string,
  patch: Partial<SongTrack>,
): SongTrack[] {
  const asset = findAssetOf(project, assetId, 'song');
  return (asset?.tracks ?? []).map((t) => (t.id === trackId ? { ...t, ...patch } : t));
}

function withItem(project: Project, assetId: string, itemId: string, patch: Partial<SongItem>): SongItem[] {
  const asset = findAssetOf(project, assetId, 'song');
  return (asset?.items ?? []).map((i) => (i.id === itemId ? { ...i, ...patch } : i));
}