background.js

browser.browserAction.onClicked.addListener(async (tab) => {
  const url = tab.url;

  // Check if the current page is an arXiv page
  if (url.includes("arxiv.org")) {
    try {
      // Execute script in the active tab to get paper information
      const result = await browser.tabs.executeScript(tab.id, {
        code: `
          (function() {
            // Function to extract arXiv ID from URL
            function extractArXivId(url) {
              // Match arXiv ID patterns in abstract or PDF URLs
              const abstractMatch = url.match(/arxiv\\.org\\/abs\\/([\\d\\.]+)/);
              const pdfMatch = url.match(/arxiv\\.org\\/pdf\\/([\\d\\.]+)/);
              return abstractMatch ? abstractMatch[1] : (pdfMatch ? pdfMatch[1] : null);
            }

            // Get arXiv ID from current URL
            const arxivId = extractArXivId(window.location.href);

            if (!arxivId) {
              return { success: false, message: "Could not find arXiv ID in URL" };
            }

            // For PDF URLs, we need to construct the abstract URL to get the title
            const isPdf = window.location.href.includes('/pdf/');

            if (isPdf) {
              // Return what we know so far for PDF pages
              return {
                success: true,
                arxivId: arxivId,
                abstractUrl: 'https://arxiv.org/abs/' + arxivId,
                isPdf: true
              };
            } else {
              // For abstract pages, extract the title directly
              const titleElement = document.querySelector("h1.title");
              const title = titleElement ? titleElement.textContent.replace('Title:', '').trim() : null;

              if (!title) {
                return { success: false, message: "Could not find paper title" };
              }

              return {
                success: true,
                title: title,
                arxivId: arxivId,
                abstractUrl: 'https://arxiv.org/abs/' + arxivId,
                isPdf: false
              };
            }
          })();
        `
      });

      const paperInfo = result[0];

      if (!paperInfo.success) {
        browser.notifications.create({
          type: "basic",
          title: "arXiv Markdown Link Generator",
          message: paperInfo.message || "Error generating markdown link"
        });
        return;
      }

      // For PDF pages, we need to fetch the abstract page to get the title
      if (paperInfo.isPdf) {
        try {
          // Create a notification that we're fetching the title
          browser.notifications.create({
            type: "basic",
            title: "arXiv Markdown Link Generator",
            message: "Fetching paper title from abstract page..."
          });

          // Execute a background fetch for the abstract page
          const titleResult = await browser.tabs.executeScript(tab.id, {
            code: `
              (function() {
                return new Promise((resolve, reject) => {
                  const xhr = new XMLHttpRequest();
                  xhr.open('GET', '${paperInfo.abstractUrl}', true);
                  xhr.onload = function() {
                    if (xhr.status === 200) {
                      const parser = new DOMParser();
                      const htmlDoc = parser.parseFromString(xhr.responseText, 'text/html');
                      const titleElement = htmlDoc.querySelector("h1.title");
                      const title = titleElement ? titleElement.textContent.replace('Title:', '').trim() : null;
                      resolve(title);
                    } else {
                      reject('Failed to fetch abstract page');
                    }
                  };
                  xhr.onerror = function() {
                    reject('Failed to fetch abstract page');
                  };
                  xhr.send();
                });
              })();
            `
          });

          const title = titleResult[0];
          if (!title) {
            throw new Error("Could not extract paper title from abstract page");
          }

          paperInfo.title = title;
        } catch (error) {
          browser.notifications.create({
            type: "basic",
            title: "arXiv Markdown Link Generator",
            message: "Failed to get paper title: " + error.message
          });
          return;
        }
      }

      // Generate markdown link
      const markdownLink = `[${paperInfo.title}](${paperInfo.abstractUrl})`;

      // Copy to clipboard
      await browser.tabs.executeScript(tab.id, {
        code: `
          (function() {
            const textarea = document.createElement('textarea');
            textarea.textContent = \`${markdownLink}\`;
            document.body.appendChild(textarea);
            textarea.select();
            document.execCommand('copy');
            document.body.removeChild(textarea);
            return true;
          })();
        `
      });

      // Show success notification
      browser.notifications.create({
        type: "basic",
        title: "Markdown Link Copied",
        message: "The markdown link has been copied to your clipboard!"
      });
    } catch (error) {
      browser.notifications.create({
        type: "basic",
        title: "Error",
        message: "Failed to generate markdown link: " + error.message
      });
    }
  } else {
    browser.notifications.create({
      type: "basic",
      title: "Not an arXiv Page",
      message: "This extension only works on arXiv pages"
    });
  }
});