1import path from "node:path";
2import type { NetworkEntry } from "../../browser/network-journal";
3import type { XMedia, XQuotedTweet, XTweet, XUser, JsonObject } from "./types";
4 
5const X_IMAGE_EXTENSIONS = new Set(["jpg", "jpeg", "png", "webp", "gif", "bmp", "avif"]);
6 
7function emptyObject(): JsonObject {
8  return {};
9}
10 
11export function isRecord(value: unknown): value is JsonObject {
12  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
13}
14 
15export function walk(value: unknown, visitor: (node: unknown) => boolean | void): boolean {
16  if (visitor(value)) {
17    return true;
18  }
19 
20  if (Array.isArray(value)) {
21    for (const item of value) {
22      if (walk(item, visitor)) {
23        return true;
24      }
25    }
26    return false;
27  }
28 
29  if (isRecord(value)) {
30    for (const child of Object.values(value)) {
31      if (walk(child, visitor)) {
32        return true;
33      }
34    }
35  }
36 
37  return false;
38}
39 
40function hasTweetText(node: JsonObject): boolean {
41  const legacy = isRecord(node.legacy) ? node.legacy : emptyObject();
42  return (
43    typeof legacy.full_text === "string" ||
44    typeof getNoteTweetText(node) === "string"
45  );
46}
47 
48export function findTweetNodeById(payload: unknown, tweetId: string): JsonObject | null {
49  let match: JsonObject | null = null;
50 
51  walk(payload, (node) => {
52    if (!isRecord(node) || typeof node.rest_id !== "string" || !isRecord(node.legacy)) {
53      return false;
54    }
55 
56    if (!hasTweetText(node)) {
57      return false;
58    }
59 
60    if (node.rest_id === tweetId) {
61      match = node;
62      return true;
63    }
64 
65    return false;
66  });
67 
68  return match;
69}
70 
71export function findTweetNode(payload: unknown, statusId: string): JsonObject | null {
72  let firstMatch: JsonObject | null = null;
73  const exactMatch = findTweetNodeById(payload, statusId);
74  if (exactMatch) {
75    return exactMatch;
76  }
77 
78  walk(payload, (node) => {
79    if (!isRecord(node) || typeof node.rest_id !== "string" || !isRecord(node.legacy)) {
80      return false;
81    }
82    if (!hasTweetText(node)) {
83      return false;
84    }
85    if (!firstMatch) {
86      firstMatch = node;
87    }
88    return false;
89  });
90 
91  return firstMatch;
92}
93 
94export function getLegacy(tweet: JsonObject): JsonObject {
95  return isRecord(tweet.legacy) ? tweet.legacy : emptyObject();
96}
97 
98export function unwrapTweetResult(node: unknown): JsonObject | null {
99  if (!isRecord(node)) {
100    return null;
101  }
102 
103  if (node.__typename === "TweetWithVisibilityResults" && isRecord(node.tweet)) {
104    return unwrapTweetResult(node.tweet);
105  }
106 
107  const tweet = isRecord(node.tweet) ? (node.tweet as JsonObject) : node;
108  if (typeof tweet.rest_id !== "string" || !isRecord(tweet.legacy)) {
109    return null;
110  }
111 
112  return tweet;
113}
114 
115export function getUser(tweet: JsonObject): XUser {
116  const result =
117    isRecord(tweet.core) &&
118    isRecord(tweet.core.user_results) &&
119    isRecord(tweet.core.user_results.result)
120      ? (tweet.core.user_results.result as JsonObject)
121      : emptyObject();
122  const legacy = isRecord(result.legacy) ? result.legacy : emptyObject();
123  const core = isRecord(result.core) ? result.core : emptyObject();
124  return {
125    name:
126      (typeof legacy.name === "string" ? legacy.name : undefined) ??
127      (typeof core.name === "string" ? core.name : undefined),
128    screenName:
129      (typeof legacy.screen_name === "string" ? legacy.screen_name : undefined) ??
130      (typeof core.screen_name === "string" ? core.screen_name : undefined),
131  };
132}
133 
134function getNoteTweetResult(tweet: JsonObject): JsonObject | null {
135  if (
136    !isRecord(tweet.note_tweet) ||
137    !isRecord(tweet.note_tweet.note_tweet_results) ||
138    !isRecord(tweet.note_tweet.note_tweet_results.result)
139  ) {
140    return null;
141  }
142 
143  return tweet.note_tweet.note_tweet_results.result as JsonObject;
144}
145 
146function getNoteTweetText(tweet: JsonObject): string | undefined {
147  const noteTweet = getNoteTweetResult(tweet);
148  return typeof noteTweet?.text === "string" ? noteTweet.text : undefined;
149}
150 
151interface TweetUrlEntity {
152  url: string;
153  expandedUrl?: string;
154  displayUrl?: string;
155}
156 
157function collectTweetUrlEntities(values: unknown[]): TweetUrlEntity[] {
158  return values.reduce<TweetUrlEntity[]>((entities, value) => {
159      if (!isRecord(value) || typeof value.url !== "string" || !value.url) {
160        return entities;
161      }
162 
163      entities.push({
164        url: value.url,
165        expandedUrl: typeof value.expanded_url === "string" ? value.expanded_url : undefined,
166        displayUrl: typeof value.display_url === "string" ? value.display_url : undefined,
167      });
168 
169      return entities;
170    }, []);
171}
172 
173function getTweetUrlEntities(tweet: JsonObject): TweetUrlEntity[] {
174  const noteTweet = getNoteTweetResult(tweet);
175  const noteTweetEntitySet = noteTweet && isRecord(noteTweet.entity_set) ? noteTweet.entity_set : emptyObject();
176  const noteTweetUrls = collectTweetUrlEntities(Array.isArray(noteTweetEntitySet.urls) ? noteTweetEntitySet.urls : []);
177 
178  const legacy = getLegacy(tweet);
179  const legacyEntities = isRecord(legacy.entities) ? legacy.entities : emptyObject();
180  const legacyUrls = collectTweetUrlEntities(Array.isArray(legacyEntities.urls) ? legacyEntities.urls : []);
181 
182  const seen = new Set<string>();
183  return [...noteTweetUrls, ...legacyUrls].filter((value) => {
184    if (seen.has(value.url)) {
185      return false;
186    }
187    seen.add(value.url);
188    return true;
189  });
190}
191 
192export function getTweetText(tweet: JsonObject): string {
193  const legacy = getLegacy(tweet);
194  let text =
195    getNoteTweetText(tweet) ?? (typeof legacy.full_text === "string" ? legacy.full_text : "");
196 
197  for (const value of getTweetUrlEntities(tweet)) {
198    const replacement =
199      (typeof value.expandedUrl === "string" && value.expandedUrl) ||
200      (typeof value.displayUrl === "string" && value.displayUrl) ||
201      value.url;
202    text = text.replaceAll(value.url, replacement);
203  }
204 
205  const extendedEntities = isRecord(legacy.extended_entities) ? legacy.extended_entities : emptyObject();
206  const media = Array.isArray(extendedEntities.media) ? extendedEntities.media : [];
207  for (const value of media) {
208    if (isRecord(value) && typeof value.url === "string") {
209      text = text.replaceAll(value.url, "").trim();
210    }
211  }
212 
213  return text.replace(/\n{3,}/g, "\n\n").trim();
214}
215 
216function normalizeXImageExtension(raw: string | undefined | null): string | undefined {
217  if (!raw) {
218    return undefined;
219  }
220 
221  const normalized = raw.replace(/^\./, "").trim().toLowerCase();
222  if (!normalized) {
223    return undefined;
224  }
225 
226  return normalized === "jpeg" ? "jpg" : normalized;
227}
228 
229export function toHighResXImageUrl(rawUrl: string): string {
230  try {
231    const parsed = new URL(rawUrl);
232    if (parsed.hostname.toLowerCase() !== "pbs.twimg.com") {
233      return rawUrl;
234    }
235 
236    const pathExtension = normalizeXImageExtension(path.posix.extname(parsed.pathname));
237    const format = normalizeXImageExtension(parsed.searchParams.get("format")) ?? pathExtension;
238    if (!format || !X_IMAGE_EXTENSIONS.has(format)) {
239      return rawUrl;
240    }
241 
242    if (pathExtension) {
243      parsed.pathname = parsed.pathname.replace(new RegExp(`\\.${pathExtension}$`, "i"), "");
244    }
245 
246    parsed.searchParams.set("format", format);
247    parsed.searchParams.set("name", "4096x4096");
248    return parsed.toString();
249  } catch {
250    return rawUrl;
251  }
252}
253 
254function getVideoVariantBitrate(variant: JsonObject): number {
255  const value = variant.bitrate ?? variant.bit_rate;
256  return typeof value === "number" && Number.isFinite(value) ? value : 0;
257}
258 
259function getVideoVariantContentType(variant: JsonObject): string {
260  const value = variant.content_type ?? variant.contentType;
261  return typeof value === "string" ? value.toLowerCase() : "";
262}
263 
264export function resolveBestXVideoVariantUrl(mediaInfo: unknown): string | undefined {
265  if (!isRecord(mediaInfo)) {
266    return undefined;
267  }
268 
269  const variantsSource =
270    Array.isArray(mediaInfo.variants)
271      ? mediaInfo.variants
272      : isRecord(mediaInfo.video_info) && Array.isArray(mediaInfo.video_info.variants)
273        ? mediaInfo.video_info.variants
274        : [];
275 
276  const variants = variantsSource
277    .filter(
278      (variant): variant is JsonObject =>
279        isRecord(variant) && typeof variant.url === "string" && variant.url.length > 0,
280    )
281    .filter((variant) => getVideoVariantContentType(variant) === "video/mp4")
282    .sort((left, right) => getVideoVariantBitrate(right) - getVideoVariantBitrate(left));
283 
284  return typeof variants[0]?.url === "string" ? variants[0].url : undefined;
285}
286 
287export function getTweetMedia(tweet: JsonObject): XMedia[] {
288  const legacy = getLegacy(tweet);
289  const extendedEntities = isRecord(legacy.extended_entities) ? legacy.extended_entities : emptyObject();
290  const media = Array.isArray(extendedEntities.media) ? extendedEntities.media : [];
291 
292  return media
293    .map((value) => {
294      if (!isRecord(value) || typeof value.type !== "string") {
295        return null;
296      }
297      if (value.type === "photo" && typeof value.media_url_https === "string") {
298        return {
299          type: value.type,
300          url: toHighResXImageUrl(value.media_url_https),
301          alt: typeof value.ext_alt_text === "string" ? value.ext_alt_text : undefined,
302        };
303      }
304      if (value.type === "video" || value.type === "animated_gif") {
305        const videoUrl = resolveBestXVideoVariantUrl(value);
306        if (!videoUrl) {
307          return null;
308        }
309        return {
310          type: value.type,
311          url: videoUrl,
312        };
313      }
314      return null;
315    })
316    .filter((value): value is XMedia => value !== null);
317}
318 
319export function getTweetUrl(tweet: JsonObject, fallbackUrl: string): string {
320  const user = getUser(tweet);
321  const fallbackScreenName = extractScreenNameFromUrl(fallbackUrl);
322  const id = typeof tweet.rest_id === "string" ? tweet.rest_id : "";
323  const screenName = user.screenName ?? fallbackScreenName;
324  if (screenName && id) {
325    return `https://x.com/${screenName}/status/${id}`;
326  }
327  return fallbackUrl;
328}
329 
330export function getQuotedTweet(tweet: JsonObject, fallbackUrl: string): XQuotedTweet | undefined {
331  const quoted = unwrapTweetResult(
332    isRecord(tweet.quoted_status_result) ? tweet.quoted_status_result.result : null,
333  );
334  if (!quoted) {
335    return undefined;
336  }
337 
338  const user = getUser(quoted);
339  return {
340    id: typeof quoted.rest_id === "string" ? quoted.rest_id : "",
341    author: user.screenName,
342    authorName: user.name,
343    text: getTweetText(quoted),
344    url: getTweetUrl(quoted, fallbackUrl),
345    media: getTweetMedia(quoted),
346  };
347}
348 
349export function extractScreenNameFromUrl(url: string): string | undefined {
350  try {
351    const parsed = new URL(url);
352    const match = parsed.pathname.match(/^\/([^/]+)\/(?:status|article)\//);
353    if (!match) {
354      return undefined;
355    }
356    if (match[1] === "i") {
357      return undefined;
358    }
359    return match[1];
360  } catch {
361    return undefined;
362  }
363}
364 
365export function toXTweet(tweet: JsonObject, fallbackUrl: string): XTweet {
366  const legacy = getLegacy(tweet);
367  const user = getUser(tweet);
368  const fallbackScreenName = extractScreenNameFromUrl(fallbackUrl);
369  const screenName = user.screenName ?? fallbackScreenName;
370  return {
371    id: typeof tweet.rest_id === "string" ? tweet.rest_id : "",
372    author: screenName,
373    authorName: user.name,
374    text: getTweetText(tweet),
375    likes: typeof legacy.favorite_count === "number" ? legacy.favorite_count : 0,
376    retweets: typeof legacy.retweet_count === "number" ? legacy.retweet_count : 0,
377    replies: typeof legacy.reply_count === "number" ? legacy.reply_count : 0,
378    createdAt: typeof legacy.created_at === "string" ? legacy.created_at : undefined,
379    inReplyTo: typeof legacy.in_reply_to_status_id_str === "string" ? legacy.in_reply_to_status_id_str : undefined,
380    url: getTweetUrl(tweet, fallbackUrl),
381    media: getTweetMedia(tweet),
382    quotedTweet: getQuotedTweet(tweet, fallbackUrl),
383  };
384}
385 
386export function normalizeTitle(text: string, fallback: string): string {
387  const firstLine = text.split("\n")[0]?.trim();
388  if (!firstLine) {
389    return fallback;
390  }
391  return firstLine.slice(0, 120);
392}
393 
394export function formatTweetAuthor(tweet: XTweet): string | undefined {
395  if (tweet.author && tweet.authorName) {
396    return `${tweet.authorName} (@${tweet.author})`;
397  }
398  if (tweet.author) {
399    return `@${tweet.author}`;
400  }
401  return tweet.authorName;
402}
403 
404export function getTweetAuthorMetadata(tweet: XTweet): Record<string, unknown> {
405  return {
406    authorName: tweet.authorName,
407    authorUsername: tweet.author,
408    authorUrl: tweet.author ? `https://x.com/${tweet.author}` : undefined,
409  };
410}
411 
412export function formatMediaList(media: XMedia[]): string[] {
413  return media.map((item) => {
414    if (item.type === "photo") {
415      return `photo: ${item.url}`;
416    }
417    return `${item.type}: ${item.url}`;
418  });
419}
420 
421export function filterXGraphQlEntries(entries: NetworkEntry[]): NetworkEntry[] {
422  return entries.filter((entry) => entry.url.includes("/graphql/"));
423}
424