Paywall for logged-in users

export async function upgrade(_req: Request, res: Response): Promise<void> {
	const user: User = res.locals.user;

	// A second click reuses the open checkout instead of creating another one.
	if (user.pendingSessionId) {
		const pending = await agentaos.checkouts.retrieve(user.pendingSessionId);
		if (pending.status === 'open') {
			res.redirect(303, pending.checkoutUrl);
			return;
		}
	}

	const checkout = await agentaos.checkouts.create({
		linkId: config.proLinkId,
		buyerEmail: user.email,
		metadata: { customerId: user.id },
		successUrl: `${config.appUrl}/success`,
		cancelUrl: `${config.appUrl}/`,
	});
	updateUser(user.id, { pendingSessionId: checkout.sessionId });
	res.redirect(303, checkout.checkoutUrl);
}

	const checkout = await agentaos.checkouts.retrieve(sessionId);
	if (checkout.metadata.customerId !== user.id) {
		res.status(404).send('Not found');
		return;
	}

	if (checkout.status === 'completed') {
		const { subscriptionId } = checkout.metadata;
		grantPro({
			userId: user.id,
			subscriptionId: typeof subscriptionId === 'string' ? subscriptionId : null,
			sessionId,
		});
	}
	res.send(successPage(user, checkout.status));

	switch (event.type) {
		case 'checkout.session.completed': {
			const { sessionId, metadata } = event.data;
			const subscriptionId =
				typeof metadata.subscriptionId === 'string' ? metadata.subscriptionId : null;
			if (typeof metadata.customerId === 'string') {
				// First payment, or the start of a free trial.
				grantPro({ userId: metadata.customerId, subscriptionId, sessionId });
			} else if (subscriptionId) {
				// A renewal carries no customerId: match it by the stored subscription ID.
				recordRenewal({ subscriptionId, sessionId });
			}
			break;
		}
		case 'subscription.updated':
		case 'subscription.canceled': {
			const user = findUserBySubscription(event.data.id);
			if (user) updateUser(user.id, { subscriptionStatus: event.data.status });
			break;
		}
	}
	res.sendStatus(200);

export function grantPro(input: {
	userId: string;
	subscriptionId: string | null;
	sessionId: string;
}): void {
	const granted = onceForSession(input.sessionId, () =>
		updateUser(input.userId, { subscriptionId: input.subscriptionId, pendingSessionId: null }),
	);

export async function findSubscription(id: string | null): Promise<Subscription | null> {
	if (!id) return null;
	for (let offset = 0; ; offset += 100) {
		const page = await agentaos.subscriptions.list({ limit: 100, offset });
		const found = page.items.find((s) => s.id === id);
		if (found) return found;
		if (!page.hasMore) return null;
	}
}

export function isPro(subscription: Subscription | null): boolean {
	return subscription?.status === 'active' || subscription?.status === 'trialing';
}

export async function userInvoices(user: User): Promise<SubscriptionInvoice[]> {
	if (!user.subscriptionId) return [];
	return agentaos.subscriptions.invoices(user.subscriptionId);
}

export async function downloadInvoice(req: Request, res: Response): Promise<void> {
	const user: User = res.locals.user;
	const id = String(req.params.id);
	const kind = req.path.endsWith('/receipt') ? 'receipt' : 'invoice';

	const invoice = (await userInvoices(user)).find((i) => i.id === id);
	if (!invoice) {
		res.status(404).send('Not found');
		return;
	}

	const pdf =
		kind === 'receipt'
			? await agentaos.invoices.getReceipt(id)
			: await agentaos.invoices.downloadPdf(id);
	res.type('application/pdf').attachment(`${kind}-${invoice.invoiceNumber}.pdf`).send(pdf);
}

export async function cancel(_req: Request, res: Response): Promise<void> {
	await agentaos.subscriptions.cancel(subscriptionOf(res));
	res.redirect(303, '/');
}

	const quote = await agentaos.subscriptions.previewPlanChange(
		subscriptionOf(res),
		config.proPlusLinkId,
	);
	res.send(quotePage(res.locals.user, quote));

	await agentaos.subscriptions.changePlan(subscriptionOf(res), {
		targetLinkId: config.proPlusLinkId,
		// The quote's prorationDate makes the charge equal the amount the user saw.
		prorationDate: Number(req.body.prorationDate),
	});