AeScriptsApi.ts

import { isEmpty } from '@src/ui/utils';
import type {
  AnyProjectIssue,
  InstalledFontData,
  ProjectData,
  ProjectInfo,
  ProjectIssueType,
  RelinkData,
} from 'plainly-types';
import { csInterface } from '../constants';

async function evalScriptAsync(func: string): Promise<string | undefined> {
  return new Promise((resolve, reject) => {
    try {
      const finalFunc = `$['com.plainlyvideos.after-effects-plugin.Panel'].${func};`;
      csInterface.evalScript(finalFunc, (result: string) => {
        if (result.includes('Error: ')) {
          reject(new Error(result));
        }

        resolve(result === 'undefined' ? undefined : result);
      });
    } catch (error) {
      reject(error);
    }
  });
}

/**
 * Typed API bridge for communicating with After Effects ExtendScript.
 * Wraps the PlainlyAE namespace exposed by the aescripts bundle.
 */
class AeScriptsApiClass {
  /**
   * Opens a folder selection dialog in After Effects.
   * @returns The selected folder path, or undefined if cancelled
   */
  async selectFolder(): Promise<string | undefined> {
    return await evalScriptAsync('selectFolder()');
  }

  /**
   * Collects InstalledFontData by PostScript name from After Effects.
   * @param postScriptName The PostScript name of the font to look up
   * @returns An array of InstalledFontData, or undefined if not found
   */
  async getInstalledFontsByPostScriptName(
    postScriptName: string,
  ): Promise<InstalledFontData[] | undefined> {
    const result = await evalScriptAsync(
      `getInstalledFontsByPostScriptName(${JSON.stringify(postScriptName)})`,
    );
    if (!result) return undefined;

    try {
      return JSON.parse(result);
    } catch {
      throw new Error('Failed to parse fonts data.');
    }
  }

  /**
   * Collects InstalledFontData by Family name and Style name from After Effects.
   * @param familyName The family name of the font to look up
   * @param styleName The style name of the font to look up
   * @returns An array of InstalledFontData, or undefined if not found
   */
  async getInstalledFontsByFamilyNameAndStyleName(
    familyName: string,
    styleName: string,
  ): Promise<InstalledFontData[] | undefined> {
    const result = await evalScriptAsync(
      `getInstalledFontsByFamilyNameAndStyleName(${JSON.stringify(familyName)}, ${JSON.stringify(styleName)})`,
    );

    if (!result) return undefined;

    try {
      return JSON.parse(result);
    } catch {
      throw new Error('Failed to parse fonts data.');
    }
  }

  /**
   * Checks if a font is installed in After Effects by PostScript name, family name, and style name.
   * @param postScriptName The PostScript name of the font to check
   * @param familyName The family name of the font to check
   * @param styleName The style name of the font to check
   * @returns True if the font is installed, false otherwise
   */
  async isFontInstalled(
    postScriptName: string,
    familyName: string,
    styleName: string,
  ): Promise<boolean> {
    let fonts = await this.getInstalledFontsByPostScriptName(postScriptName);

    if (isEmpty(fonts)) {
      fonts = await this.getInstalledFontsByFamilyNameAndStyleName(
        familyName,
        styleName,
      );

      if (fonts === undefined) {
        // Could not get fonts by either methods, continue
        return true;
      }

      if (isEmpty(fonts)) {
        return false;
      }
    }

    if (fonts[0]?.isSubstitute) {
      return false;
    }

    return true;
  }

  /**
   * Collects all fonts and footage from the current After Effects project.
   * @returns Project information including fonts and footage arrays
   */
  async collectFiles(): Promise<ProjectInfo> {
    const result = await evalScriptAsync('collectFiles()');
    if (!result) throw new Error('Failed to collect files');

    try {
      return JSON.parse(result);
    } catch {
      throw new Error('Failed to parse collected files data.');
    }
  }

  /**
   * Sets Plainly project metadata in the After Effects project XMP.
   * @param id - The Plainly project ID
   * @param revisionCount - The project revision count
   */
  async setProjectData(id: string, revisionCount: number): Promise<void> {
    await evalScriptAsync(
      `setProjectData(${JSON.stringify(id)}, ${JSON.stringify(revisionCount)})`,
    );
  }

  /**
   * Retrieves Plainly project metadata from the After Effects project XMP.
   * @returns Project data including documentId, id, and revisionCount
   */
  async getProjectData(): Promise<ProjectData | undefined> {
    const result = await evalScriptAsync('getProjectData()');
    if (!result) return undefined;

    try {
      return JSON.parse(result);
    } catch {
      throw new Error('Failed to parse project data.');
    }
  }

  /**
   * Removes Plainly project metadata from the After Effects project XMP.
   */
  async removeProjectData(): Promise<void> {
    await evalScriptAsync('removeProjectData()');
  }

  /**
   * Gets the file system path of the current After Effects project.
   * @returns The project file path, or undefined if project is not saved
   */
  async getProjectPath(): Promise<string | undefined> {
    return await evalScriptAsync('getProjectPath()');
  }

  /**
   * Saves the current After Effects project.
   */
  async saveProject(): Promise<void> {
    await evalScriptAsync('saveProject()');
  }

  /**
   * Gets the version of After Effects.
   * @returns The version of After Effects as a string
   */
  async getAfterEffectsVersion(): Promise<string> {
    const result = await evalScriptAsync('getAfterEffectsVersion()');
    if (!result) throw new Error('Failed to get After Effects version');
    return result;
  }

  /**
   * Returns all layer names in a given After Effects composition.
   * @param compId - The ID of the composition
   * @returns An array of layer names
   */
  async getCompLayerNames(compId: number): Promise<string[]> {
    const result = await evalScriptAsync(
      `getCompLayerNames(${JSON.stringify(compId)})`,
    );
    if (!result) return [];
    try {
      return JSON.parse(result);
    } catch {
      throw new Error('Failed to parse layer names data.');
    }
  }

  /**
   * Relinks footage items in the After Effects project to new file paths.
   * @param relinkData - Object mapping item IDs to new file paths
   */
  async relinkFootage(relinkData: RelinkData): Promise<void> {
    await evalScriptAsync(`relinkFootage(${JSON.stringify(relinkData)})`);
  }

  /**
   * Selects a layer in the current After Effects composition by its ID.
   * @param layerId - The ID of the layer to select
   */
  async selectLayer(layerId: string): Promise<void> {
    await evalScriptAsync(`selectLayer(${JSON.stringify(layerId)})`);
  }

  /**
   *  Selects a composition in After Effects by its ID.
   * @param compId - The ID of the composition to select
   */
  async selectComp(compId: string): Promise<void> {
    await evalScriptAsync(`selectComp(${JSON.stringify(compId)})`);
  }

  /**
   * Selects a file item in the After Effects project by its ID.
   * @param fileId - The ID of the file item to select
   */
  async selectFile(fileId: string): Promise<void> {
    await evalScriptAsync(`selectFile(${JSON.stringify(fileId)})`);
  }

  /**
   * Validates the current After Effects project for Plainly issues.
   * @returns An array of validation issues, or an empty array if no issues found
   */
  async validateProject(): Promise<AnyProjectIssue[]> {
    const result = await evalScriptAsync('validateProject()');
    if (!result) return [];

    try {
      return JSON.parse(result);
    } catch {
      throw new Error('Failed to parse validation results.');
    }
  }

  /**
   * Fixes all provided Plainly issues in the After Effects project.
   * @param issues - Array of project issues to fix
   */
  async fixAllIssues(
    issues: AnyProjectIssue[],
    ignoreFixing: {
      [key in ProjectIssueType]?: boolean;
    },
  ): Promise<void> {
    await evalScriptAsync(
      `fixAllIssues(${JSON.stringify(issues)}, ${JSON.stringify(ignoreFixing)})`,
    );
  }

  /**
   * Fixes unsupported 3D renderer issues for multiple compositions
   * @param compIds - Array of composition IDs to fix
   */
  async fixUnsupported3DRendererIssues(compIds: string[]): Promise<void> {
    await evalScriptAsync(
      `fixUnsupported3DRendererIssues(${JSON.stringify(compIds)})`,
    );
  }
}

/**
 * Singleton instance of the AeScriptsApi.
 * Use this to make typed calls to After Effects ExtendScript functions.
 *
 * @example
 * ```typescript
 * import { AeScriptsApi } from './bridge/AeScriptsApi';
 *
 * // Save project
 * await AeScriptsApi.saveProject();
 *
 * // Get project data
 * const projectData = await AeScriptsApi.getProjectData();
 * console.log(projectData.id);
 * ```
 */
export const AeScriptsApi = new AeScriptsApiClass();