Made of little things.

import { intent } from '@napplet/sdk';
import { runtimeHasDomain } from './domain-availability.js';
import { validateMap } from './model';
import type { BlackSiteMap } from './model';

export type MapIntentAction = 'edit' | 'remix' | 'new' | 'open';
export interface MapIntentTarget {
    address: string;
    author: string;
    id: string;
    relays: string[];
}
export interface MapIntent {
    action: MapIntentAction;
    sender: string;
    target?: MapIntentTarget;
    map?: BlackSiteMap;
}
export const MAP_INTENT_CONVENTIONS = [
    'napplet:black-site/map-edit',
    'napplet:black-site/map-remix',
    'napplet:black-site/map-new',
    'napplet:black-site/map-open',
] as const;
const object = (value: unknown): value is Record<string, unknown> =>
    Boolean(value) && typeof value === 'object' && !Array.isArray(value);
function boundedJson(value: unknown, maxBytes: number) {
    let raw: string | undefined;
    try {
        raw = JSON.stringify(value);
    } catch {
        throw new Error('Map intent payload must be plain JSON.');
    }
    if (raw === undefined || new TextEncoder().encode(raw).length > maxBytes)
        throw new Error('Map intent payload exceeds its size limit.');
}
function keysOnly(value: Record<string, unknown>, keys: string[]) {
    if (Object.keys(value).some((key) => !keys.includes(key)))
        throw new Error('Map intent payload contains unsupported fields.');
}
function relayHint(value: unknown): string {
    if (typeof value !== 'string' || value.length > 256)
        throw new Error('Map intent relay hints must be public WSS URLs.');
    let url: URL;
    try {
        url = new URL(value);
    } catch {
        throw new Error('Map intent relay hint is invalid.');
    }
    if (
        url.protocol !== 'wss:' ||
        url.username ||
        url.password ||
        url.hash ||
        (url.port && url.port !== '443') ||
        url.hostname === 'localhost' ||
        url.hostname.endsWith('.localhost') ||
        url.hostname.endsWith('.local') ||
        url.hostname.startsWith('[') ||
        /^\d+(?:\.\d+){3}$/.test(url.hostname)
    )
        throw new Error('Map intent relay hints must be public WSS URLs on port 443.');
    return url.href;
}
/** Validate a runtime delivery; sender labels are attribution, never edit authority. */
export function parseMapIntent(delivery: unknown): MapIntent {
    if (!object(delivery)) throw new Error('Map intent delivery is invalid.');
    if (
        typeof delivery.convention !== 'string' ||
        !(MAP_INTENT_CONVENTIONS as readonly string[]).includes(delivery.convention)
    )
        throw new Error('Unsupported map intent convention.');
    const action = delivery.convention.slice('napplet:black-site/map-'.length) as MapIntentAction;
    if (delivery.archetype !== 'black-site' || delivery.action !== `map-${action}`)
        throw new Error('Map intent routing fields do not match its convention.');
    if (
        typeof delivery.sender !== 'string' ||
        !delivery.sender ||
        delivery.sender.length > 1024 ||
        /[\u0000-\u001f]/.test(delivery.sender)
    )
        throw new Error('Map intent source label is invalid.');
    const payload = delivery.payload === undefined ? {} : delivery.payload;
    if (!object(payload)) throw new Error('Map intent payload must be an object.');
    boundedJson(payload, action === 'new' ? 264192 : 4096);
    if (action === 'new') {
        keysOnly(payload, ['map']);
        if (payload.map === undefined) return { action, sender: delivery.sender };
        const errors = validateMap(payload.map);
        if (errors.length) throw new Error(`Map handoff is invalid:\n${errors.join('\n')}`);
        boundedJson(payload.map, 262144);
        return {
            action,
            sender: delivery.sender,
            map: JSON.parse(JSON.stringify(payload.map)) as BlackSiteMap,
        };
    }
    keysOnly(payload, ['address', 'relays']);
    if (typeof payload.address !== 'string')
        throw new Error('Map intent requires a published map address.');
    const match = /^35858:([0-9a-f]{64}):([a-z0-9][a-z0-9-]{0,31})$/.exec(payload.address);
    if (!match) throw new Error('Map intent address must be 35858:<author hex>:<map ID>.');
    if (
        payload.relays !== undefined &&
        (!Array.isArray(payload.relays) || payload.relays.length > 8)
    )
        throw new Error('Map intent accepts at most eight relay hints.');
    const relays = [...new Set(((payload.relays as unknown[] | undefined) ?? []).map(relayHint))];
    return {
        action,
        sender: delivery.sender,
        target: { address: payload.address, author: match[1], id: match[2], relays },
    };
}
/** Official receiver API only; the injected runtime buffers pre-registration deliveries. */
export function subscribeMapIntents(
    handler: (request: MapIntent) => void | Promise<void>,
    onError: (error: unknown) => void,
): { close(): void } {
    if (!runtimeHasDomain('intent')) return { close() {} };
    let live = true;
    let subscription: { close(): void };
    try {
        subscription = intent.onDelivery((delivery) => {
            if (!live) return;
            try {
                Promise.resolve(handler(parseMapIntent(delivery))).catch((error) => {
                    if (live) onError(error);
                });
            } catch (error) {
                onError(error);
            }
        });
    } catch (error) {
        onError(error);
        return { close() {} };
    }
    return {
        close() {
            live = false;
            subscription.close();
        },
    };
}