wordeck/apps/api/src/routes/share.ts

import { Hono } from 'hono';

import { parseEnvelope, validatePayloadForType } from '@cards/domain';

import manifest from '../../../../app-manifest.json' with { type: 'json' };

import { getDb, type CardsDb } from '../db/connection.ts';
import { authMiddleware, type AuthVars } from '../middleware/auth.ts';
import { SHARE_HANDLERS, type ShareHandlerName } from '../share-handlers/index.ts';

export type ShareDeps = { db?: CardsDb };

/** Manifest-Lookup: Type → Handler-Name. */
const ACCEPTS_BY_TYPE = new Map(manifest.accepts.map((a) => [a.type, a.handler] as const));

export function shareRouter(deps: ShareDeps = {}): Hono<{ Variables: AuthVars }> {
	const r = new Hono<{ Variables: AuthVars }>();
	const dbOf = () => deps.db ?? getDb();

	r.use('*', authMiddleware);

	r.post('/receive', async (c) => {
		const userId = c.get('userId');

		// Body kann `{ envelope, delivery_token }` oder direkt der Envelope sein.
		const body = await c.req.json().catch(() => null);
		if (!body || typeof body !== 'object') {
			return c.json({ accepted: false, reason: 'invalid_json' }, 400);
		}
		const wrapped = body as { envelope?: unknown; delivery_token?: string };
		const rawEnvelope = wrapped.envelope ?? body;
		// const deliveryToken = wrapped.delivery_token; // Phase F-1: validieren

		// 1. Schema-Validierung (inkl. Cross-User-Sperre)
		const parsed = parseEnvelope(rawEnvelope);
		if (!parsed.success) {
			return c.json(
				{
					accepted: false,
					reason: 'envelope_invalid',
					issues: parsed.error.issues.map(
						(i) => `${i.path.join('.') || '<root>'}: ${i.message}`
					),
				},
				422
			);
		}
		const env = parsed.data;

		// 2. User-Match
		if (env.to.user_id !== userId) {
			return c.json({ accepted: false, reason: 'user_id_mismatch' }, 403);
		}

		// 3. Empfänger-App-Match
		if (env.to.app !== manifest.id) {
			return c.json(
				{
					accepted: false,
					reason: 'wrong_recipient',
					expected: manifest.id,
					actual: env.to.app,
				},
				422
			);
		}

		// 4. Type akzeptiert?
		const handlerName = ACCEPTS_BY_TYPE.get(env.type);
		if (!handlerName) {
			return c.json(
				{ accepted: false, reason: 'type_not_accepted', type: env.type },
				422
			);
		}

		// 5. Payload validieren gegen sein eigenes Schema
		const payloadCheck = validatePayloadForType(env.type, env.payload);
		if (!payloadCheck.success) {
			return c.json(
				{
					accepted: false,
					reason: payloadCheck.error,
					issues: 'issues' in payloadCheck ? payloadCheck.issues : undefined,
				},
				422
			);
		}

		// 6. Handler holen + dispatchen
		const handler = SHARE_HANDLERS[handlerName as ShareHandlerName];
		if (!handler) {
			return c.json(
				{ accepted: false, reason: 'handler_not_registered', handler: handlerName },
				501
			);
		}

		try {
			const result = await handler(dbOf(), userId, payloadCheck.data as never);
			return c.json({
				accepted: true,
				target_link: result.target_link,
				resulting_id: result.resulting_id,
			});
		} catch (e) {
			return c.json(
				{
					accepted: false,
					reason: 'handler_error',
					message: (e as Error).message,
				},
				500
			);
		}
	});

	return r;
}