ontime/apps/client/src/views/teleprompter/teleprompter.utils.ts

import { type CustomFields, isOntimeEvent, isOntimeGroup, type MaybeString, type Rundown } from 'ontime-types';

import type { RundownMetadataObject } from '../../common/utils/rundownMetadata';
import { getPropertyValue } from '../common/viewUtils';
import type { HeadingSource, ScriptBlock, TeleprompterOptions } from './teleprompter.types';

type BuildScriptOptions = Pick<
  TeleprompterOptions,
  'scriptSource' | 'heading' | 'hideEmpty' | 'hidePast' | 'showGroups'
>;

/**
 * Resolves the heading shown above a script block.
 */
function makeHeading(source: HeadingSource, cue: string, title: string): string {
  switch (source) {
    case 'cue':
      return cue;
    case 'title':
      return title;
    case 'both':
      return [cue, title].filter(Boolean).join(' · ');
    case 'none':
      return '';
  }
}

/**
 * An image custom field holds a URL, which is meaningless to read aloud.
 * The params editor filters these out of the select, but the URL can be hand typed.
 */
function isReadableSource(scriptSource: string, customFields: CustomFields): boolean {
  if (!scriptSource.startsWith('custom-')) {
    return true;
  }
  const key = scriptSource.slice('custom-'.length);
  return customFields[key]?.type === 'text';
}

/**
 * Flattens the rundown into the continuous document the prompter scrolls through.
 *
 * We iterate flatOrder so that events nested in groups arrive in reading order
 * without a second pass.
 */
export function buildScript(
  rundown: Rundown,
  rundownMetadata: RundownMetadataObject,
  customFields: CustomFields,
  options: BuildScriptOptions,
): ScriptBlock[] {
  const { scriptSource, heading, hideEmpty, hidePast, showGroups } = options;

  if (!scriptSource || scriptSource === 'none' || !isReadableSource(scriptSource, customFields)) {
    return [];
  }

  const blocks: ScriptBlock[] = [];
  let lastGroupId: MaybeString = null;

  for (const id of rundown.flatOrder) {
    const entry = rundown.entries[id];
    if (!isOntimeEvent(entry) || entry.skip) {
      continue;
    }

    const metadata = rundownMetadata[id];
    if (hidePast && metadata?.isPast) {
      continue;
    }

    const text = getPropertyValue(entry, scriptSource, rundown.entries)?.trim() ?? '';
    if (hideEmpty && !text) {
      continue;
    }

    // a group title is emitted once, on the first block that belongs to it
    const groupId = metadata?.groupId ?? null;
    let groupTitle: MaybeString = null;
    if (showGroups && groupId && groupId !== lastGroupId) {
      const group = rundown.entries[groupId];
      groupTitle = isOntimeGroup(group) ? group.title : null;
    }
    lastGroupId = groupId;

    blocks.push({
      id,
      heading: makeHeading(heading, entry.cue, entry.title),
      text,
      groupTitle,
      isLoaded: Boolean(metadata?.isLoaded),
    });
  }

  return blocks;
}

/**
 * Folds Ontime's global "Flip Screen" toggle into the per view flips.
 *
 * The shared `.mirror` class is `rotate(180deg)`, which is the same matrix as
 * `scale(-1, -1)`: a flip on both axes at once. So the global toggle is exactly
 * the pair of flips this view already has, and composing them with XOR keeps the
 * teleprompter behaving like every other view without two transforms competing
 * for the same property.
 *
 * It cannot replace the per view flips, though. A rotation preserves handedness,
 * so it never yields the mirror image a beam splitter reflection needs; only a
 * single axis flip does. That is why both exist.
 */
export function composeFlip(flipH: boolean, flipV: boolean, isMirrored: boolean): { flipH: boolean; flipV: boolean } {
  return { flipH: flipH !== isMirrored, flipV: flipV !== isMirrored };
}