/**
 * PR-19 smoke — status-page subscriber service contract.
 *
 * Pure-function-ish: exercises isValidSubscriberEmail across edge
 * cases + verifies the StatusSubscriberService swallows mail errors
 * during fan-out (one failed subscriber doesn't break the whole
 * batch).
 *
 * The end-to-end browser path (subscribe form -> confirm email ->
 * confirm link -> incident notify) is documented in the PR-19 test
 * plan and exercised in the live dev server.
 *
 * Run: npx tsx scripts/smoke/pr19-status-subscribers.ts
 */
import './_lib';
import { ok, fail } from './_lib';
import {
    isValidSubscriberEmail,
    generateSubscriberToken,
    StatusSubscriberService,
} from '../../src/lib/services/status-subscriber.service';

async function main(): Promise<void> {
    // Email validation
    if (!isValidSubscriberEmail('alice@example.com')) fail('PR-19 email-ok', 'valid email rejected');
    if (isValidSubscriberEmail('header\r\ninject@evil.com')) fail('PR-19 email-inject', 'header-injection email accepted');
    if (isValidSubscriberEmail('no-at-sign')) fail('PR-19 email-nopeppy', 'malformed email accepted');
    if (isValidSubscriberEmail('a'.repeat(255) + '@x.com')) fail('PR-19 email-toolong', 'oversize email accepted');
    ok('isValidSubscriberEmail accepts good + rejects bad shapes');

    // Token shape
    const tok = generateSubscriberToken();
    if (!/^[a-f0-9]{64}$/.test(tok)) fail('PR-19 token-shape', `bad token: ${tok}`);
    if (generateSubscriberToken() === generateSubscriberToken()) fail('PR-19 token-fresh', 'tokens collide');
    ok('generateSubscriberToken returns fresh 64-hex strings');

    // Fan-out keeps going if one subscriber's email fails
    let sendCount = 0;
    const mailer = {
        sendConfirm: async () => undefined,
        sendIncident: async (args: { to: string }) => {
            sendCount++;
            if (args.to === 'bad@example.com') throw new Error('bounced');
        },
        sendResolved: async () => undefined,
    };
    const fakePrisma = {
        statusPageSubscriber: {
            findMany: async () => [
                { id: 1, email: 'ok-1@example.com', unsubscribeToken: 'u'.repeat(64) },
                { id: 2, email: 'bad@example.com', unsubscribeToken: 'v'.repeat(64) },
                { id: 3, email: 'ok-2@example.com', unsubscribeToken: 'w'.repeat(64) },
            ],
            update: async () => undefined,
            findUnique: async () => null,
            create: async () => undefined,
            delete: async () => undefined,
        },
    };
    const svc = new StatusSubscriberService({
        prisma: fakePrisma as never,
        mailer,
        baseUrl: 'https://example.com',
    });
    const sent = await svc.notifyIncidentOpen({ id: 1, title: 't', description: 'd' });
    if (sendCount !== 3) fail('PR-19 fanout-attempts', `expected 3 attempts, got ${sendCount}`);
    if (sent !== 2) fail('PR-19 fanout-success', `expected 2 successful, got ${sent}`);
    ok('fan-out attempts every confirmed subscriber + survives one bad address');

    ok('PR-19 status-subscribers smoke', 'subscriber service contract holds');
}

main().catch((e) => fail('PR-19 crashed', String(e)));