1import type { AdapterContext } from "../types";
2import { extractThreadTweetsFromPayloads } from "./thread";
3import { collectXJsonPayloads, getRelevantXThreadEntries, prefetchRelevantXThreadBodies } from "./payloads";
4 
5interface ClickTextResult {
6  clicked: boolean;
7  text?: string;
8}
9 
10interface ScrollStepResult {
11  moved: boolean;
12  atTop: boolean;
13  atBottom: boolean;
14}
15 
16interface ThreadProgress {
17  tweetCount: number;
18  firstTweetId?: string;
19  lastTweetId?: string;
20  requestCount: number;
21  tweetDetailCount: number;
22}
23 
24interface TopProbeState {
25  requestCount: number;
26  tweetDetailCount: number;
27  scrollHeight: number;
28}
29 
30function sleep(ms: number): Promise<void> {
31  return new Promise((resolve) => setTimeout(resolve, ms));
32}
33 
34async function waitForXNetworkSettle(context: AdapterContext, reason: string): Promise<void> {
35  try {
36    await context.network.waitForIdle({
37      idleMs: 650,
38      timeoutMs: Math.min(context.timeoutMs, 5_000),
39    });
40  } catch {
41    context.log.debug(`Network idle timed out after ${reason}.`);
42  }
43}
44 
45async function captureTopProbeState(context: AdapterContext): Promise<TopProbeState> {
46  const entries = getRelevantXThreadEntries(context);
47  const scrollHeight = await context.browser.evaluate<number>(`
48    (() => {
49      const scrollRoot = document.scrollingElement ?? document.documentElement ?? document.body;
50      return scrollRoot.scrollHeight;
51    })()
52  `);
53 
54  return {
55    requestCount: entries.length,
56    tweetDetailCount: entries.filter((entry) => entry.url.includes("TweetDetail")).length,
57    scrollHeight,
58  };
59}
60 
61async function waitForTopProbe(context: AdapterContext): Promise<boolean> {
62  const initial = await captureTopProbeState(context);
63  const deadline = Date.now() + 1_200;
64 
65  while (Date.now() < deadline) {
66    try {
67      await context.network.waitForIdle({
68        idleMs: 250,
69        timeoutMs: 350,
70      });
71    } catch {
72      // Keep polling until the shorter top-probe budget expires.
73    }
74 
75    await prefetchRelevantXThreadBodies(context);
76    const next = await captureTopProbeState(context);
77    if (
78      next.requestCount > initial.requestCount ||
79      next.tweetDetailCount > initial.tweetDetailCount ||
80      next.scrollHeight > initial.scrollHeight + 4
81    ) {
82      context.log.debug("Observed additional X thread activity while probing the page top.");
83      return true;
84    }
85 
86    await sleep(120);
87  }
88 
89  return false;
90}
91 
92async function scrollThreadToTop(context: AdapterContext): Promise<void> {
93  let settledTopChecks = 0;
94 
95  while (settledTopChecks < 2) {
96    const scroll = await context.browser.evaluate<ScrollStepResult>(`
97      (() => {
98        const scrollRoot = document.scrollingElement ?? document.documentElement ?? document.body;
99        const before = window.scrollY;
100        window.scrollTo({ top: 0, left: 0, behavior: "instant" });
101        const after = window.scrollY;
102        return {
103          moved: after !== before,
104          atTop: after <= 4,
105          atBottom: window.innerHeight + after >= scrollRoot.scrollHeight - 4,
106        };
107      })()
108    `);
109    await sleep(140);
110    await waitForXNetworkSettle(context, "scrolling X thread to top");
111    await prefetchRelevantXThreadBodies(context);
112 
113    if (scroll.moved) {
114      settledTopChecks = 0;
115      continue;
116    }
117 
118    const observedTopActivity = await waitForTopProbe(context);
119    if (observedTopActivity) {
120      settledTopChecks = 0;
121      continue;
122    }
123 
124    settledTopChecks += 1;
125  }
126}
127 
128async function clickVisibleShowReplies(context: AdapterContext): Promise<ClickTextResult> {
129  return context.browser.evaluate<ClickTextResult>(`
130    (() => {
131      const normalize = (value) => value.replace(/\\s+/g, " ").trim();
132      const matches = [
133        /^Show replies$/i,
134        /^Show more replies$/i,
135        /^Show additional replies$/i,
136        /^显示回复$/,
137        /^展开回复$/,
138      ];
139      const isVisible = (element) => {
140        if (!(element instanceof HTMLElement)) {
141          return false;
142        }
143        const rect = element.getBoundingClientRect();
144        const style = window.getComputedStyle(element);
145        return (
146          rect.width > 0 &&
147          rect.height > 0 &&
148          style.visibility !== "hidden" &&
149          style.display !== "none"
150        );
151      };
152 
153      const selectors = [
154        "a",
155        "button",
156        '[role="button"]',
157        '[role="link"]',
158      ];
159 
160      for (const element of document.querySelectorAll(selectors.join(","))) {
161        if (!isVisible(element)) {
162          continue;
163        }
164        const text = normalize(element.textContent ?? "");
165        if (!text || !matches.some((pattern) => pattern.test(text))) {
166          continue;
167        }
168        element.scrollIntoView({ block: "center", inline: "nearest" });
169        if (element instanceof HTMLElement) {
170          element.click();
171          return { clicked: true, text };
172        }
173      }
174 
175      return { clicked: false };
176    })()
177  `);
178}
179 
180async function expandVisibleShowReplies(context: AdapterContext): Promise<number> {
181  let clickCount = 0;
182 
183  while (clickCount < 8) {
184    const result = await clickVisibleShowReplies(context).catch<ClickTextResult>(() => ({ clicked: false }));
185    if (!result.clicked) {
186      break;
187    }
188 
189    clickCount += 1;
190    context.log.debug(`Expanded X thread replies via "${result.text ?? "Show replies"}".`);
191    await sleep(250);
192    await waitForXNetworkSettle(context, "expanding Show replies");
193    await prefetchRelevantXThreadBodies(context);
194  }
195 
196  return clickCount;
197}
198 
199async function scrollThreadBy(context: AdapterContext, stepPx: number): Promise<ScrollStepResult> {
200  const result = await context.browser.evaluate<ScrollStepResult>(`
201    (() => {
202      const scrollRoot = document.scrollingElement ?? document.documentElement ?? document.body;
203      const before = window.scrollY;
204      window.scrollBy({ top: ${stepPx}, left: 0, behavior: "instant" });
205      const after = window.scrollY;
206      return {
207        moved: after !== before,
208        atTop: after <= 4,
209        atBottom: window.innerHeight + after >= scrollRoot.scrollHeight - 4,
210      };
211    })()
212  `);
213 
214  await sleep(140);
215  await waitForXNetworkSettle(context, "scrolling X thread");
216  await prefetchRelevantXThreadBodies(context);
217  return result;
218}
219 
220async function captureThreadProgress(context: AdapterContext, statusId: string): Promise<ThreadProgress> {
221  const entries = getRelevantXThreadEntries(context);
222  const payloads = await collectXJsonPayloads(context);
223  const tweets = extractThreadTweetsFromPayloads(payloads, statusId, context.input.url.toString());
224  return {
225    tweetCount: tweets.length,
226    firstTweetId: tweets[0]?.id,
227    lastTweetId: tweets[tweets.length - 1]?.id,
228    requestCount: entries.length,
229    tweetDetailCount: entries.filter((entry) => entry.url.includes("TweetDetail")).length,
230  };
231}
232 
233export async function loadFullXThread(context: AdapterContext, statusId: string): Promise<void> {
234  await scrollThreadToTop(context);
235 
236  let progress = await captureThreadProgress(context, statusId);
237  let stagnantRounds = 0;
238  let roundsWithoutMovement = 0;
239  let distanceWithoutThreadActivityPx = 0;
240 
241  for (let round = 0; ; round += 1) {
242    const stepPx = round < 12 ? 1_200 : 1_600;
243    let expandedCount = await expandVisibleShowReplies(context);
244    const scroll = await scrollThreadBy(context, stepPx);
245    expandedCount += await expandVisibleShowReplies(context);
246    const nextProgress = await captureThreadProgress(context, statusId);
247    const grew =
248      nextProgress.tweetCount > progress.tweetCount ||
249      nextProgress.firstTweetId !== progress.firstTweetId ||
250      nextProgress.lastTweetId !== progress.lastTweetId ||
251      nextProgress.requestCount > progress.requestCount ||
252      nextProgress.tweetDetailCount > progress.tweetDetailCount;
253 
254    if (grew) {
255      context.log.debug(
256        `X thread progress: ${nextProgress.tweetCount} tweets (${nextProgress.firstTweetId ?? "unknown"} -> ${nextProgress.lastTweetId ?? "unknown"}), ${nextProgress.requestCount} requests, ${nextProgress.tweetDetailCount} TweetDetail.`,
257      );
258      stagnantRounds = 0;
259      distanceWithoutThreadActivityPx = 0;
260    } else if (expandedCount > 0) {
261      stagnantRounds = 0;
262      distanceWithoutThreadActivityPx = 0;
263    } else {
264      stagnantRounds += 1;
265      distanceWithoutThreadActivityPx += stepPx;
266    }
267 
268    roundsWithoutMovement = scroll.moved ? 0 : roundsWithoutMovement + 1;
269    progress = nextProgress;
270 
271    if (scroll.atBottom && stagnantRounds >= 6) {
272      context.log.debug("Stopping X thread scroll after reaching page bottom with no further thread progress.");
273      break;
274    }
275 
276    if (roundsWithoutMovement >= 2 && stagnantRounds >= 4) {
277      context.log.debug("Stopping X thread scroll after repeated downward scrolls no longer move the page.");
278      break;
279    }
280 
281    if (distanceWithoutThreadActivityPx >= 24_000 && stagnantRounds >= 12) {
282      context.log.debug("Stopping X thread scroll after a long stretch with no thread-related progress.");
283      break;
284    }
285  }
286}
287