import type { Person } from './types';

export interface Mention {
  user_id: string;
  text: string;
}

export interface MentionQuery {
  start: number;
  query: string;
}

const MXID = /@[a-z0-9._=\-/+]+:[a-zA-Z0-9.\-]+(?::\d+)?/g;
const MAX_CANDIDATES = 8;

/** The `@word` the caret sits in, when it starts at a word boundary. */
export function mentionQueryAt(text: string, caret: number): MentionQuery | null {
  const before = text.slice(0, caret);
  const at = before.lastIndexOf('@');
  if (at < 0) return null;
  if (at > 0 && !/\s/.test(before[at - 1])) return null;
  const query = before.slice(at + 1);
  if (query.length > 64 || /\s/.test(query)) return null;
  return { start: at, query };
}

export function rankPeople(people: Person[], query: string, exclude: string | null): Person[] {
  const q = query.toLowerCase();
  const scored: { person: Person; score: number }[] = [];
  for (const person of people) {
    if (person.user_id === exclude) continue;
    const name = person.name.toLowerCase();
    const id = person.user_id.toLowerCase();
    let score: number;
    if (!q) score = 3;
    else if (name.startsWith(q) || id.startsWith(`@${q}`) || id.startsWith(q)) score = 0;
    else if (name.split(/\s+/).some((word) => word.startsWith(q))) score = 1;
    else if (name.includes(q) || id.includes(q)) score = 2;
    else continue;
    scored.push({ person, score });
  }
  scored.sort((a, b) => a.score - b.score || a.person.name.localeCompare(b.person.name));
  return scored.slice(0, MAX_CANDIDATES).map((s) => s.person);
}

/** Picked names still present in the body, plus any full matrix ids typed by hand. */
export function resolveMentions(body: string, picked: Mention[]): Mention[] {
  const out: Mention[] = [];
  const seen = new Set<string>();
  for (const m of picked) {
    const key = `${m.user_id}\n${m.text}`;
    if (seen.has(key) || !m.text || !body.includes(m.text)) continue;
    seen.add(key);
    out.push(m);
  }
  for (const match of body.matchAll(MXID)) {
    const key = `${match[0]}\n${match[0]}`;
    if (seen.has(key)) continue;
    seen.add(key);
    out.push({ user_id: match[0], text: match[0] });
  }
  return out;
}

let scratch: HTMLElement | null = null;

/** User pills already in a sent message, so editing it keeps them linked. */
export function mentionsFromHtml(html: string | null): Mention[] {
  if (!html) return [];
  scratch ??= document.implementation.createHTMLDocument('').body;
  scratch.innerHTML = html;
  try {
    const out: Mention[] = [];
    for (const a of scratch.querySelectorAll('a[href^="https://matrix.to/#/@"]')) {
      const userId = decodeURIComponent(a.getAttribute('href')!.slice('https://matrix.to/#/'.length).split('?')[0]);
      const text = a.textContent ?? '';
      if (text) out.push({ user_id: userId, text });
    }
    return out;
  } finally {
    scratch.replaceChildren();
  }
}

const MARKDOWN_PILL = /\[([^\]\n]+)\]\(https:\/\/matrix\.to\/#\/(@[^)\s?]+)[^)\s]*\)/g;

/** Some clients send `[name](https://matrix.to/#/@user)` as the plain body instead of just the name. */
export function stripMarkdownPills(body: string): { text: string; mentions: Mention[] } {
  const mentions: Mention[] = [];
  const text = body.replace(MARKDOWN_PILL, (whole: string, name: string, id: string) => {
    try {
      mentions.push({ user_id: decodeURIComponent(id), text: name });
      return name;
    } catch {
      return whole;
    }
  });
  return { text, mentions };
}

export function mentionedUserIds(mentions: Mention[]): string[] {
  return [...new Set(mentions.map((m) => m.user_id))];
}