/**
 * Description: In Firebot Events, add this file to "Run Custom Script"
 * in an event triggered by "Stream Started".
 * This script will:
 * - fetch stream description, title and thumbnail from the OpenGraph meta tags
 * - create a session with Bluesky
 * - upload the thumbnail as a blob to Bluesky
 * - create the app.bsky.actor.status record that enables the live badge
 */

/**
 * Firebot-specific code block below.
 * You will have to change this if you are using a different bot.
 */
exports.run = (runRequest) => {
  const logger = runRequest.modules.logger;
  const {
    BSKY_HANDLE,
    APP_PASSWORD,
    PDS_HOST,
    TWITCH_USERNAME,
    DURATION,
  } = runRequest.parameters;
  goLive(
    BSKY_HANDLE,
    APP_PASSWORD,
    PDS_HOST,
    TWITCH_USERNAME,
    DURATION,
    logger,
  );
};
exports.getScriptManifest = function () {
  return {
    name: "Go Live on Bluesky",
    description:
      "Creates the app.bsky.actor.status record via API that enables the live badge on Bluesky.",
    author: "timtinkers.online",
    version: "1.1.0",
    website: "https://tangled.org/timtinkers.online/",
    startupOnly: false,
    firebotVersion: "5",
  };
};
exports.getDefaultParameters = function getDefaultParameters() {
  return new Promise((resolve, reject) => {
    resolve({
      BSKY_HANDLE: {
        "type": "string",
        "description": "Your full Bluesky handle",
        "default": "alice.bsky.social",
      },
      APP_PASSWORD: {
        "type": "string",
        "description":
          "App-password created at https://bsky.app/settings/app-passwords.\nNEVER share your app password with anyone else, it gives full API access to your account!",
        "default": "xxxx-xxxx-xxxx-xxxx",
      },
      PDS_HOST: {
        "type": "string",
        "description":
          "URL of your host Personal Data Server, do not change if you don't know what that is!",
        "default": "https://bsky.social",
      },
      TWITCH_USERNAME: {
        "type": "string",
        "description": "Your Twitch username, that will be linked in the badge",
        "default": "twitchdev",
      },
      DURATION: {
        "type": "number",
        "description":
          "Duration in minutes you expect to be live for, maximum 240 minutes",
        "default": 240,
      },
    });
  });
};

/**
 * Extracts OpenGraph data from the HTML document of the Twitch URL
 */
async function extractOpenGraphData(url, logger) {
  try {
    logger.info(`Fetching OpenGraph data from: ${url}`);
    const response = await fetch(url, {
      // Setting a user agent so Twitch doesn't spend time loading JS
      headers: {
        "User-Agent":
          "facebookexternalhit/1.1 (+http://www.facebook.com/externalhit_uatext.php)",
      },
    });

    if (!response.ok) {
      logger.error(
        `Failed to fetch Twitch page: ${response.status} ${response.statusText}`,
      );
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }

    const html = await response.text();

    const getMetaContent = (property) => {
      // Try property/name first, then content
      const regex1 = new RegExp(
        `<meta\\s+(?:property|name)="${property}"\\s+content="([^"]*)"`,
        "i",
      );
      // Try content first, then property/name
      const regex2 = new RegExp(
        `<meta\\s+content="([^"]*)"\\s+(?:property|name)="${property}"`,
        "i",
      );

      const match = html.match(regex1) || html.match(regex2);
      return match ? match[1] : null;
    };

    const ogData = {
      title: getMetaContent("og:title"),
      description: getMetaContent("og:description"),
      image: getMetaContent("og:image"),
    };

    logger.debug(`OpenGraph data extracted: ${JSON.stringify(ogData)}`);
    return ogData;
  } catch (error) {
    logger.error(`Error extracting OpenGraph data: ${error.message}`);
    throw error;
  }
}

/**
 * Creates the app.bsky.actor.status record via API
 */
async function goLive(
  handle,
  password,
  pdsHost,
  twitchUsername,
  duration,
  logger,
) {
  try {
    logger.info("Starting Bluesky live badge creation");

    // 1. Extract OpenGraph data from Twitch URL
    const twitchUrl = `https://www.twitch.tv/${twitchUsername}`;
    const ogData = await extractOpenGraphData(twitchUrl, logger);

    // 2. Create session
    logger.info("Authenticating with Bluesky");
    const createSession = await fetch(
      pdsHost + "/xrpc/com.atproto.server.createSession",
      {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ identifier: handle, password: password }),
      },
    );

    if (!createSession.ok) {
      const errorText = await createSession.text();
      logger.error(
        `Bluesky authentication failed: ${createSession.status} ${createSession.statusText}`,
      );
      logger.error(`Error details: ${errorText}`);
      throw new Error(`Auth failed: ${createSession.status}`);
    }

    const { did, accessJwt } = await createSession.json();
    logger.debug(`Authenticated successfully. DID: ${did}`);

    // 3. Upload thumbnail blob
    let blob;
    if (ogData.image) {
      try {
        logger.info(`Uploading thumbnail: ${ogData.image}`);

        // First, fetch the image from the URL
        const imageResponse = await fetch(ogData.image);
        if (!imageResponse.ok) {
          logger.error(
            `Failed to fetch thumbnail: ${imageResponse.status} ${imageResponse.statusText}`,
          );
          throw new Error(`Image fetch failed: ${imageResponse.status}`);
        }

        const imageBlob = await imageResponse.blob();
        logger.debug(
          `Thumbnail fetched, size: ${imageBlob.size} bytes, type: ${imageBlob.type}`,
        );

        // Then upload it to Bluesky
        const blobRes = await fetch(
          pdsHost + "/xrpc/com.atproto.repo.uploadBlob",
          {
            method: "POST",
            headers: {
              "Content-Type": imageBlob.type,
              Authorization: `Bearer ${accessJwt}`,
            },
            body: imageBlob,
          },
        );

        if (!blobRes.ok) {
          const errorText = await blobRes.text();
          logger.error(
            `Blob upload failed: ${blobRes.status} ${blobRes.statusText}`,
          );
          logger.error(`Error details: ${errorText}`);
          throw new Error(`Blob upload failed: ${blobRes.status}`);
        }

        const blobData = await blobRes.json();
        blob = blobData.blob;
        logger.info("Thumbnail uploaded successfully");
      } catch (error) {
        logger.error(`Error during thumbnail upload: ${error.message}`);
        logger.info("Continuing without thumbnail");
        blob = null;
      }
    } else {
      logger.info("No thumbnail found in OpenGraph data");
    }

    // 4. Create the live actor status record
    logger.info("Creating live status record");

    // Check if app.bsky.actor.status exists
    const writes = [];
    const getRecordRes = await fetch(
      `${pdsHost}/xrpc/com.atproto.repo.getRecord?repo=${
        encodeURIComponent(did)
      }&collection=app.bsky.actor.status&rkey=self`,
      {
        method: "GET",
        headers: {
          "Content-Type": "application/json",
        },
      },
    );
    // If exists, queue delete
    if (getRecordRes.ok) {
      writes.push({
        $type: "com.atproto.repo.applyWrites#delete",
        collection: "app.bsky.actor.status",
        rkey: "self",
      });
    }

    // Set up new app.bsky.actor.status
    const record = {
      $type: "app.bsky.actor.status",
      embed: {
        $type: "app.bsky.embed.external",
        external: {
          uri: twitchUrl,
          $type: "app.bsky.embed.external#external",
          thumb: blob || {},
          title: ogData.title || `${twitchUsername} - Twitch`,
          description: ogData.description ||
            `${twitchUsername} streams live on Twitch!`,
        },
      },
      status: "app.bsky.actor.status#live",
      createdAt: new Date().toISOString(),
      durationMinutes: typeof duration === "number"
        ? Math.max(10, Math.min(240, Math.round(duration)))
        : 240,
    };
    // Queue create
    writes.push({
      $type: "com.atproto.repo.applyWrites#create",
      collection: "app.bsky.actor.status",
      rkey: "self",
      value: record,
    });

    const postRes = await fetch(
      pdsHost + "/xrpc/com.atproto.repo.applyWrites",
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessJwt}`,
        },
        body: JSON.stringify({
          repo: did,
          writes: writes,
        }),
      },
    );

    if (!postRes.ok) {
      const errorText = await postRes.text();
      logger.error(
        `Failed to create live status: ${postRes.status} ${postRes.statusText}`,
      );
      logger.error(`Error details: ${errorText}`);
      throw new Error(`Post failed: ${postRes.status}`);
    }

    const result = await postRes.json();
    logger.info(`Live badge created successfully! URI: ${result.uri}`);
    return result;
  } catch (error) {
    logger.error(`Fatal error in goLive: ${error.message}`);
    logger.error(`Stack trace: ${error.stack}`);
    throw error;
  }
}