import { ResolveError, type Media, type Post, type Segment } from '../types.ts';
import { readOpenGraph } from '../browser/capture.ts';
import { findCaption, findMetaMedia, mediaFromMetaNode, metaHeaders, type MetaMediaNode } from './meta-media.ts';
import { hostMatcher } from './url.ts';
import type { PlatformSpec, ResolveContext } from './types.ts';

const REFERER = 'https://www.threads.com/';

/** One post as Threads ships it, alongside the media fields Instagram shares. */
type ThreadsPost = MetaMediaNode & {
  code?: string;
  taken_at?: number;
  caption?: { text?: string };
  user?: { username?: string };
  text_post_app_info?: {
    reply_to_author?: { username?: string };
  };
};

type ThreadContainer = {
  thread_items?: Array<{ post?: ThreadsPost }>;
};

function handleFromPath(pathRest: string): string | undefined {
  return /^(@[^/]+)/.exec(pathRest)?.[1];
}

function codeFromPath(pathRest: string): string | undefined {
  return /\/post\/([A-Za-z0-9_-]+)/.exec(`/${pathRest}`)?.[1];
}

/** Threads ships its Relay payloads in `<script type="application/json">`
 *  tags, several dozen of them, in an order not worth relying on. */
async function inlinePayloads(ctx: ResolveContext): Promise<unknown[]> {
  const raw = await ctx.page
    .evaluate(() =>
      [...document.querySelectorAll('script[type="application/json"]')]
        .map((el) => el.textContent ?? '')
        .filter((text) => text.length > 64),
    )
    .catch(() => [] as string[]);

  return raw.flatMap((text) => {
    try {
      return [JSON.parse(text) as unknown];
    } catch {
      return [];
    }
  });
}

/** Every post the page shipped, from the thread containers it renders. */
export function collectPosts(root: unknown): ThreadsPost[] {
  const seen = new Set<unknown>();
  const queue: unknown[] = [root];
  const posts: ThreadsPost[] = [];

  for (let i = 0; i < queue.length; i += 1) {
    const value = queue[i];
    if (value === null || typeof value !== 'object' || seen.has(value)) continue;
    seen.add(value);

    if (Array.isArray(value)) {
      queue.push(...value);
      continue;
    }

    const record = value as Record<string, unknown>;
    const items = (record as ThreadContainer).thread_items;
    if (Array.isArray(items)) {
      for (const item of items) {
        if (item?.post?.code) posts.push(item.post);
      }
    }
    queue.push(...Object.values(record));
  }

  return posts;
}

/**
 * The author's own chain, and nothing else.
 *
 * The page carries three kinds of post: the linked one, the author's
 * follow-ups, and a pile of other people's replies and recommendations. A
 * follow-up is the author replying to themselves, which is exactly what
 * `reply_to_author` distinguishes — someone else replying to the same post
 * carries the same field with a different name on it.
 */
export function selfThread(posts: ThreadsPost[], anchorCode: string | undefined): ThreadsPost[] {
  const anchor = anchorCode ? posts.find((p) => p.code === anchorCode) : undefined;
  const author = anchor?.user?.username;
  if (!anchor || !author) return [];

  // Same author, oldest first. Everyone else is a reply or a recommendation.
  const mine = [...new Map(
    posts.filter((p) => p.user?.username === author && p.code).map((p) => [p.code, p]),
  ).values()].sort((a, b) => (a.taken_at ?? 0) - (b.taken_at ?? 0));

  const at = mine.findIndex((p) => p.code === anchor.code);
  if (at === -1) return [anchor];

  // A post continues the one before it when it is the author replying to
  // themselves. Walk out from the anchor in both directions for as long as
  // that holds: the link may point at the middle of a thread, and the first
  // post of a thread is not a reply to anything, so it can only be reached
  // backwards from the one that answers it.
  const continues = (post: ThreadsPost | undefined): boolean =>
    post?.text_post_app_info?.reply_to_author?.username === author;

  let first = at;
  while (first > 0 && continues(mine[first])) first -= 1;

  let last = at;
  while (last + 1 < mine.length && continues(mine[last + 1])) last += 1;

  return mine.slice(first, last + 1);
}

function segmentOf(post: ThreadsPost, isAnchor: boolean): Segment {
  return {
    ...(post.caption?.text ? { text: post.caption.text } : {}),
    media: mediaFromMetaNode(post, REFERER),
    ...(post.taken_at ? { postedAt: new Date(post.taken_at * 1000).toISOString() } : {}),
    ...(isAnchor ? { isAnchor: true } : {}),
  };
}

/** The floor, when the structured payload is not there to be read. */
async function fromOpenGraph(ctx: ResolveContext): Promise<Segment | undefined> {
  const og = await readOpenGraph(ctx.page);
  const fetchHeaders = metaHeaders(REFERER);
  const media: Media[] = [];

  if (og['og:video']) {
    media.push({
      kind: 'video',
      url: og['og:video'],
      fetchHeaders,
      ...(og['og:image'] ? { poster: { url: og['og:image'], fetchHeaders } } : {}),
    });
  } else if (og['og:image']) {
    media.push({ kind: 'image', url: og['og:image'], fetchHeaders });
  }

  const text = og['og:description'];
  if (media.length === 0 && !text) return undefined;
  return { media, ...(text ? { text } : {}), isAnchor: true };
}

async function resolve(ctx: ResolveContext): Promise<Post> {
  const { page, originalUrl, pathRest } = ctx;

  await page.goto(originalUrl, { waitUntil: 'domcontentloaded' });

  const payloads = await inlinePayloads(ctx);
  const chain = selfThread(collectPosts(payloads), codeFromPath(pathRest));

  let segments: Segment[] = chain.map((post) =>
    segmentOf(post, post.code === codeFromPath(pathRest)),
  );

  if (segments.length === 0) {
    // No thread containers. Fall back to whatever single post is readable.
    const node = findMetaMedia(payloads);
    const caption = findCaption(payloads);
    if (node ?? caption) {
      segments = [{
        media: node ? mediaFromMetaNode(node, REFERER) : [],
        ...(caption ? { text: caption } : {}),
        isAnchor: true,
      }];
    }
  }

  if (segments.length === 0) {
    const og = await fromOpenGraph(ctx);
    if (og) segments = [og];
  }

  // A Threads post is often only words, so empty media is a fine result --
  // but nothing at all is a failure.
  if (segments.length === 0) {
    throw new ResolveError('Threads returned nothing for that URL', 'threads', originalUrl);
  }

  const handle = chain[0]?.user?.username ?? handleFromPath(pathRest)?.slice(1) ?? 'threads';
  return {
    platform: 'threads',
    platformLabel: 'Threads',
    originalUrl,
    author: { handle: `@${handle}` },
    textPosition: 'above',
    segments,
  };
}

export const threads: PlatformSpec = {
  id: 'threads',
  label: 'Threads',
  prefix: 'threads',
  canonicalHost: 'www.threads.com',
  textPosition: 'above',
  matchesHost: hostMatcher('threads.net', 'threads.com'),
  resolve,
};