Google Sheets

// Typecast API Configuration
const TYPECAST_API_KEY = "YOUR_API_KEY_HERE"; // Replace with your actual API key
const TYPECAST_API_URL = "https://api.typecast.ai/v1/text-to-speech";

/**
 * Creates custom menu when spreadsheet opens
 */
function onOpen() {
  const ui = SpreadsheetApp.getUi();
  ui.createMenu("🎙️ Typecast TTS")
    .addItem("Generate All Audio", "generateAllAudio")
    .addItem("Generate Selected Rows", "generateSelectedAudio")
    .addSeparator()
    .addItem("Clear Audio URLs", "clearAudioUrls")
    .addToUi();
}

/**
 * Generates audio for all rows with text
 */
function generateAllAudio() {
  const sheet = SpreadsheetApp.getActiveSheet();
  const lastRow = sheet.getLastRow();

  if (lastRow < 2) {
    SpreadsheetApp.getUi().alert("No data to process!");
    return;
  }

  // Get all data at once for better performance
  const dataRange = sheet.getRange(2, 1, lastRow - 1, 4);
  const data = dataRange.getValues();

  let successCount = 0;
  let errorCount = 0;

  // Process each row
  data.forEach((row, index) => {
    const text = row[0];
    const voiceNameOrId = row[1];
    const language = row[2] || "eng"; // Default to English if not specified
    const rowNumber = index + 2;

    // Skip if text or voice name/ID is empty
    if (!text || !voiceNameOrId) {
      return;
    }

    // Skip if audio URL already exists
    if (row[3]) {
      return;
    }

    try {
      const audioUrl = callTypecastAPI(text, voiceNameOrId, language);
      sheet.getRange(rowNumber, 4).setValue(audioUrl);
      successCount++;

      // Add a small delay to avoid rate limiting
      Utilities.sleep(500);
    } catch (error) {
      sheet.getRange(rowNumber, 4).setValue("Error: " + error.message);
      errorCount++;
    }
  });

  SpreadsheetApp.getUi().alert(
    `Generation complete!\n\nSuccess: ${successCount}\nErrors: ${errorCount}`,
  );
}

/**
 * Generates audio for selected rows only
 */
function generateSelectedAudio() {
  const sheet = SpreadsheetApp.getActiveSheet();
  const selection = sheet.getActiveRange();
  const startRow = selection.getRow();
  const numRows = selection.getNumRows();

  if (startRow === 1) {
    SpreadsheetApp.getUi().alert("Please select data rows (not the header)");
    return;
  }

  let successCount = 0;
  let errorCount = 0;

  for (let i = 0; i < numRows; i++) {
    const rowNumber = startRow + i;
    const text = sheet.getRange(rowNumber, 1).getValue();
    const voiceNameOrId = sheet.getRange(rowNumber, 2).getValue();
    const language = sheet.getRange(rowNumber, 3).getValue() || "eng";

    if (!text || !voiceNameOrId) {
      continue;
    }

    try {
      const audioUrl = callTypecastAPI(text, voiceNameOrId, language);
      sheet.getRange(rowNumber, 4).setValue(audioUrl);
      successCount++;

      Utilities.sleep(500);
    } catch (error) {
      sheet.getRange(rowNumber, 4).setValue("Error: " + error.message);
      errorCount++;
    }
  }

  SpreadsheetApp.getUi().alert(
    `Generation complete!\n\nSuccess: ${successCount}\nErrors: ${errorCount}`,
  );
}

/**
 * Clears all audio URLs from column D
 */
function clearAudioUrls() {
  const sheet = SpreadsheetApp.getActiveSheet();
  const lastRow = sheet.getLastRow();

  if (lastRow < 2) {
    return;
  }

  const response = SpreadsheetApp.getUi().alert(
    "Clear Audio URLs",
    "Are you sure you want to clear all audio URLs?",
    SpreadsheetApp.getUi().ButtonSet.YES_NO,
  );

  if (response === SpreadsheetApp.getUi().Button.YES) {
    sheet.getRange(2, 4, lastRow - 1, 1).clearContent();
    SpreadsheetApp.getUi().alert("Audio URLs cleared!");
  }
}

/**
 * Gets voice ID from voice name by calling the Voices API
 * @param {string} voiceName - Voice name to look up
 * @returns {string} Voice ID (e.g., tc_66aca22c7d31e45ff05ff418)
 */
function getVoiceIdByName(voiceName) {
  const url = "https://api.typecast.ai/v2/voices";

  const options = {
    method: "get",
    headers: {
      "X-API-KEY": TYPECAST_API_KEY,
    },
    muteHttpExceptions: true,
  };

  const response = UrlFetchApp.fetch(url, options);
  const responseCode = response.getResponseCode();

  if (responseCode !== 200) {
    throw new Error(`Failed to fetch voices: ${responseCode}`);
  }

  const voices = JSON.parse(response.getContentText());

  // Search for voice by name (case-insensitive)
  const searchName = voiceName.toLowerCase().trim();
  const voice = voices.find((v) => v.voice_name.toLowerCase() === searchName);

  if (!voice) {
    throw new Error(
      `Voice "${voiceName}" not found. Please check the voice name or use voice ID instead.`,
    );
  }

  return voice.voice_id;
}

/**
 * Calls the Typecast API to generate speech
 * @param {string} text - Text to convert to speech
 * @param {string} voiceNameOrId - Voice name (e.g., "Emily") or Voice ID (e.g., "tc_66aca22c7d31e45ff05ff418")
 * @param {string} language - Language code (eng, kor, jpn, cmn, etc.)
 * @returns {string} URL to the generated audio file
 */
function callTypecastAPI(text, voiceNameOrId, language) {
  // Trim and validate inputs
  text = String(text).trim();
  voiceNameOrId = String(voiceNameOrId).trim();
  language = String(language || "eng").trim();

  if (!text || !voiceNameOrId) {
    throw new Error("Text and Voice Name/ID are required");
  }

  // Determine if input is voice ID or name
  // Voice IDs start with "tc_"
  let voiceId;
  if (voiceNameOrId.startsWith("tc_")) {
    voiceId = voiceNameOrId;
    Logger.log("Using voice ID: " + voiceId);
  } else {
    // It's a voice name, look up the ID
    Logger.log("Looking up voice name: " + voiceNameOrId);
    voiceId = getVoiceIdByName(voiceNameOrId);
    Logger.log("Found voice ID: " + voiceId);
  }

  // Log for debugging
  Logger.log("Calling API with text: " + text);
  Logger.log("Language: " + language);

  const payload = {
    voice_id: voiceId,
    text: text,
    model: "ssfm-v30",
    language: language,
    prompt: {
      emotion_type: "smart", // Enable Smart Emotion for natural-sounding speech
    },
    output: {
      audio_format: "mp3",
    },
  };

  // Log payload for debugging
  Logger.log("Payload: " + JSON.stringify(payload));

  const options = {
    method: "post",
    contentType: "application/json",
    headers: {
      "X-API-KEY": TYPECAST_API_KEY,
    },
    payload: JSON.stringify(payload),
    muteHttpExceptions: true,
  };

  const response = UrlFetchApp.fetch(TYPECAST_API_URL, options);
  const responseCode = response.getResponseCode();

  if (responseCode !== 200) {
    const errorBody = response.getContentText();
    Logger.log("Error response: " + errorBody);
    throw new Error(`API Error: ${responseCode} - ${errorBody}`);
  }

  // Get the audio blob
  const audioBlob = response.getBlob();

  // Upload to Google Drive
  const folder = DriveApp.getRootFolder(); // Or specify a folder
  const fileName = `typecast_${new Date().getTime()}.mp3`;
  const file = folder.createFile(audioBlob.setName(fileName));

  // Set file to be accessible with link
  file.setSharing(DriveApp.Access.ANYONE_WITH_LINK, DriveApp.Permission.VIEW);

  // Return the file URL
  return file.getUrl();
}