const folder = "20 Areas/20.6 Diary/2024"; // Replace with your folder path
const pages = dv.pages(`"${folder}"`);
const linkCounts = {};

// Count unique links per page
for (const page of pages) {
  const uniqueLinks = new Set(page.file.outlinks.map((link) => link.path)); // Collect unique links in the current page
  uniqueLinks.forEach((linkPath) => {
    linkCounts[linkPath] = (linkCounts[linkPath] || 0) + 1;
  });
}

// Convert to an array, sort by frequency, and take the top 3
const sortedLinks = Object.entries(linkCounts)
  .sort((a, b) => b[1] - a[1])
  .slice(0, 5);

// Display as a table
dv.table(["Person Mentioned", "Amount of Times Mentioned"], sortedLinks);

---
title: "{{VALUE:Title}}"
franchise:
type: { { VALUE:typeLink } }
genres: { { VALUE:genreLinks } }
cover:
status:
rating:
progress:
total:
episodeLen:
watchedDate:
year:
---

> [!question] # ⭐️ WHAT IT'S ABOUT
>
> - ⭐️ {{VALUE:Plot}}

> [!note] # 🌙 THOUGHTS AND FEELINGS
>
> - 🌙

<image/>
{{VALUE:Poster}}

---

> [!done] # ✨️ + EXTRAS
>
> - ✨️

---

> [!tip] # 🪐 WHAT DID I FEEL WHEN FINISHED THE MOVIE/SHOW?
>
> - 🪐

// Function to extract all links from file content
async function getLinksFromContent(content) {
  const urlRegex = /(https?:\/\/[^\s]+)/g;
  const matches = [...content.matchAll(urlRegex)];
  return matches.map((match) => match[0]); // Return an array of links
}

// Function to fetch media and verify it's an image
async function fetchMedia(url) {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      console.error(`Failed to fetch URL: ${url}`);
      return null;
    }

    // Check if the content is an image
    const contentType = response.headers.get("Content-Type");
    if (!contentType || !contentType.startsWith("image/")) {
      console.error(`URL is not an image: ${url}`);
      return null;
    }

    // Get the image as a Blob
    const blob = await response.blob();
    const arrayBuffer = await blob.arrayBuffer();
    const uint8Array = new Uint8Array(arrayBuffer);

    return { uint8Array, contentType };
  } catch (error) {
    console.error(`Error fetching media from URL: ${url}`, error);
    return null;
  }
}
async function writeMediaToDisk(app, activeFile, links) {
  // Determine the parent directory of the active file
  const activeFilePath = activeFile.path;
  const parentDir = activeFilePath.substring(
    0,
    activeFilePath.lastIndexOf("/"),
  );
  const attachmentsPath = `${parentDir}/attachments`;

  // Ensure the attachments folder exists
  let folder = app.vault.getAbstractFileByPath(attachmentsPath);
  if (!folder) {
    await app.vault.createFolder(attachmentsPath);
  }

  let content = await app.vault.read(activeFile);

  for (const url of links) {
    const media = await fetchMedia(url);
    if (!media) continue;

    // Generate a unique file name
    const ext = media.contentType.split("/")[1];
    const fileName = `${Date.now()}.${ext}`;
    const fullPath = `${attachmentsPath}/${fileName}`;

    // Use Vault.create to write the image to the disk
    try {
      await app.vault.createBinary(fullPath, media.uint8Array);
    } catch (error) {
      console.error(`Error creating file at ${fullPath}:`, error);
      continue;
    }

    // Replace the URL in the content with a local link
    const localLink = `![[${fullPath}]]`;
    content = content.replace(url, localLink);

    content = content.replace("\ncover:", "\ncover: " + `${fileName}`);
  }

  // Update the active file with modified content
  await app.vault.modify(activeFile, content);
  new Notice("All images downloaded and linked successfully.");
}

async function processLinks(app) {
  const activeFile = app.workspace.getActiveFile();
  if (!activeFile) {
    new Notice("No active file is currently open.");
    return;
  }

  const content = await app.vault.read(activeFile);
  const links = await getLinksFromContent(content);

  if (links.length === 0) {
    new Notice("No links found in the file.");
    return;
  }

  await writeMediaToDisk(app, activeFile, links);
}

module.exports = {
  entry: start,
  settings: {
    name: "Link to Image",
    author: "Maximilian Mauroner",
  },
};

async function start(params) {
  const app = params.app;
  await processLinks(app);
}