1import path from "node:path";
2import { mkdir, writeFile } from "node:fs/promises";
3import {
4  buildFileName,
5  isDataUri,
6  normalizeContentType,
7  normalizeMediaUrl,
8  resolveExtensionFromContentType,
9  resolveExtensionFromUrl,
10  resolveMediaKind,
11  resolveOutputExtension,
12  toPosixPath,
13} from "./media-utils";
14import type { MediaAsset, MediaDownloadRequest, MediaDownloadResult, MediaKind } from "./types";
15 
16const DOWNLOAD_USER_AGENT =
17  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36";
18 
19function parseBase64DataUri(rawUrl: string): { contentType: string; bytes: Buffer } | null {
20  const match = rawUrl.match(/^data:([^;,]+);base64,([A-Za-z0-9+/=\s]+)$/i);
21  if (!match?.[1] || !match[2]) {
22    return null;
23  }
24 
25  const contentType = normalizeContentType(match[1]);
26  if (!contentType) {
27    return null;
28  }
29 
30  try {
31    const bytes = Buffer.from(match[2].replace(/\s+/g, ""), "base64");
32    if (bytes.length === 0) {
33      return null;
34    }
35    return { contentType, bytes };
36  } catch {
37    return null;
38  }
39}
40 
41function dedupeMedia(media: MediaAsset[]): MediaAsset[] {
42  const deduped: MediaAsset[] = [];
43  const seen = new Set<string>();
44  for (const item of media) {
45    const normalizedUrl = normalizeMediaUrl(item.url);
46    if (!normalizedUrl || seen.has(normalizedUrl)) {
47      continue;
48    }
49    seen.add(normalizedUrl);
50    deduped.push({
51      ...item,
52      url: normalizedUrl,
53    });
54  }
55  return deduped;
56}
57 
58function toRelativePath(fromDir: string, absoluteTarget: string): string {
59  const relative = path.relative(fromDir, absoluteTarget) || path.basename(absoluteTarget);
60  return toPosixPath(relative);
61}
62 
63export async function downloadMediaAssets(
64  request: MediaDownloadRequest,
65): Promise<MediaDownloadResult> {
66  const dedupedMedia = dedupeMedia(request.media);
67  const absoluteOutputPath = path.resolve(request.outputPath);
68  const markdownDir = path.dirname(absoluteOutputPath);
69  const baseDir = request.mediaDir ? path.resolve(request.mediaDir) : markdownDir;
70  const replacements: MediaDownloadResult["replacements"] = [];
71 
72  let downloadedImages = 0;
73  let downloadedVideos = 0;
74 
75  for (const asset of dedupedMedia) {
76    try {
77      let sourceUrl = normalizeMediaUrl(asset.url);
78      let contentType = "";
79      let extension: string | undefined;
80      let kind: MediaKind | undefined;
81      let bytes: Buffer | null = null;
82 
83      if (isDataUri(asset.url)) {
84        const parsed = parseBase64DataUri(asset.url);
85        if (!parsed) {
86          request.log.warn(`Skipping unsupported embedded media: ${asset.url.slice(0, 32)}...`);
87          continue;
88        }
89 
90        contentType = parsed.contentType;
91        extension =
92          resolveExtensionFromContentType(contentType) ??
93          resolveExtensionFromUrl(asset.fileNameHint ?? "");
94        kind = resolveMediaKind(sourceUrl, contentType, extension, asset.kind);
95        bytes = parsed.bytes;
96      } else {
97        const response = await fetch(sourceUrl, {
98          method: "GET",
99          redirect: "follow",
100          headers: {
101            "user-agent": DOWNLOAD_USER_AGENT,
102            ...(asset.headers ?? {}),
103          },
104        });
105 
106        if (!response.ok) {
107          request.log.warn(`Skipping media (${response.status}): ${asset.url}`);
108          continue;
109        }
110 
111        sourceUrl = normalizeMediaUrl(response.url || sourceUrl);
112        contentType = normalizeContentType(response.headers.get("content-type"));
113        extension =
114          resolveExtensionFromUrl(sourceUrl) ??
115          resolveExtensionFromUrl(asset.url) ??
116          resolveExtensionFromUrl(asset.fileNameHint ?? "");
117        kind = resolveMediaKind(sourceUrl, contentType, extension, asset.kind);
118        bytes = Buffer.from(await response.arrayBuffer());
119      }
120 
121      if (!kind || !bytes) {
122        request.log.debug(`Skipping media with unresolved kind: ${asset.url}`);
123        continue;
124      }
125 
126      const outputExtension = resolveOutputExtension(contentType, extension, kind);
127      const nextIndex = kind === "image" ? downloadedImages + 1 : downloadedVideos + 1;
128      const dirName = kind === "image" ? "imgs" : "videos";
129      const targetDir = path.join(baseDir, dirName);
130      await mkdir(targetDir, { recursive: true });
131 
132      const fileName = buildFileName(kind, nextIndex, sourceUrl, outputExtension, asset.fileNameHint);
133      const absolutePath = path.join(targetDir, fileName);
134      await writeFile(absolutePath, bytes);
135 
136      replacements.push({
137        url: asset.url,
138        localPath: toRelativePath(markdownDir, absolutePath),
139        absolutePath,
140        kind,
141      });
142 
143      if (kind === "image") {
144        downloadedImages = nextIndex;
145      } else {
146        downloadedVideos = nextIndex;
147      }
148    } catch (error) {
149      const message = error instanceof Error ? error.message : String(error);
150      request.log.warn(`Failed to download media ${asset.url}: ${message}`);
151    }
152  }
153 
154  return {
155    replacements,
156    downloadedImages,
157    downloadedVideos,
158    imageDir: downloadedImages > 0 ? path.join(baseDir, "imgs") : null,
159    videoDir: downloadedVideos > 0 ? path.join(baseDir, "videos") : null,
160  };
161}
162