// Pure helpers for the chat-input @-mention autocomplete. Kept framework-free
// so the suggestion building and the caret-context detection are unit-testable.

export type MentionSuggestionKind = 'user' | 'alias';

export interface MentionSuggestion
{
    key: string;
    kind: MentionSuggestionKind;
    name: string;
    insertToken: string;
    figure?: string;
    description?: string;
}

export type MentionAliasScope = 'everyone' | 'friends' | 'room';

export interface MentionAlias
{
    key: string;
    scope: MentionAliasScope;
    description: string;
}

export interface MentionContext
{
    atIndex: number;
    replaceFrom: number;
    replaceTo: number;
    query: string;
}

export const MAX_MENTION_SUGGESTIONS = 8;

const USER_TYPE_REAL_USER = 1;

export const MENTION_ALIAS_CONFIG_KEY: Record<MentionAliasScope, string> = {
    everyone: 'mentions_ui.aliases.everyone',
    friends:  'mentions_ui.aliases.friends',
    room:     'mentions_ui.aliases.room'
};

export const MENTION_ALIAS_DEFAULTS: Record<MentionAliasScope, string[]> = {
    everyone: [ 'all', 'everyone', 'tutti' ],
    friends:  [ 'friends', 'amici' ],
    room:     [ 'room', 'stanza' ]
};

export const MENTION_ALIAS_DESCRIPTION_KEY: Record<MentionAliasScope, string> = {
    everyone: 'mentions.alias.description.everyone',
    friends:  'mentions.alias.description.friends',
    room:     'mentions.alias.description.room'
};

export const sanitizeAliasList = (raw: unknown, fallback: string[]): string[] =>
{
    if(!Array.isArray(raw)) return fallback;

    const out: string[] = [];

    for(const entry of raw)
    {
        if(typeof entry !== 'string') continue;

        const trimmed = entry.trim();

        if(!trimmed) continue;

        out.push(trimmed);
    }

    return out;
};

/**
 * Detect an in-progress `@partial` token at the END of the input. Returns the
 * token bounds + the query (text after `@`), or null when not in a mention (no
 * trailing `@token`, `@` glued to a previous word, or a command popover open).
 * End-anchored (no caret read) so it stays a pure render-safe computation.
 */
export const computeMentionContext = (value: string, commandSelectorVisible: boolean): MentionContext | null =>
{
    if(!value) return null;
    if(commandSelectorVisible) return null;

    const match = /(?:^|\s)@([A-Za-z0-9_]*)$/.exec(value);

    if(!match) return null;

    const query = match[1];
    const atIndex = value.length - query.length - 1;

    return { atIndex, replaceFrom: atIndex, replaceTo: value.length, query };
};

interface MentionRoomUser
{
    webID?: number;
    type?: number;
    name?: string;
    figure?: string;
}

/**
 * Build the suggestion list for the current query: real room users (minus the
 * viewer themselves — match by id, name as fallback) then the broadcast
 * aliases, prefix-filtered and capped.
 */
export const buildChatMentionSuggestions = (
    query: string,
    roomUserList: ReadonlyArray<MentionRoomUser>,
    aliases: ReadonlyArray<MentionAlias>,
    ownUserId: number,
    ownUsername: string,
    max: number = MAX_MENTION_SUGGESTIONS
): MentionSuggestion[] =>
{
    const q = (query || '').toLowerCase();
    const ownNameLower = (ownUsername || '').toLowerCase();
    const out: MentionSuggestion[] = [];

    for(const user of (roomUserList || []))
    {
        if(out.length >= max) break;
        if(!user || (user.type !== USER_TYPE_REAL_USER)) continue;
        if(!user.name) continue;
        // You can't mention yourself — skip the own user (match by id, name as fallback).
        if((user.webID === ownUserId) || (ownNameLower && (user.name.toLowerCase() === ownNameLower))) continue;
        if((q.length > 0) && !user.name.toLowerCase().startsWith(q)) continue;

        out.push({ key: `user:${ user.webID }`, kind: 'user', name: user.name, insertToken: user.name, figure: user.figure || '' });
    }

    for(const alias of aliases)
    {
        if(out.length >= max) break;
        if((q.length > 0) && !alias.key.toLowerCase().startsWith(q)) continue;

        out.push({ key: `alias:${ alias.key }`, kind: 'alias', name: alias.key, insertToken: alias.key, description: alias.description });
    }

    return out;
};