/**
 * Subscription + payment REST endpoints.
 *
 * GET    /subscriptions/:userId          — get user subscription
 * POST   /subscriptions                  — create subscription
 * PUT    /subscriptions/:id              — update subscription
 * GET    /payments/:userId               — list user payments
 * POST   /payments                       — record a payment
 */

import type { FastifyInstance } from 'fastify';
import { PRODUCT_ID } from '../../lib/product-config.js';
import { BadRequestError, NotFoundError } from '../../lib/errors.js';
import * as repo from './repository.js';
import {
  CreateSubscriptionSchema,
  UpdateSubscriptionSchema,
  CreatePaymentSchema,
  type SubscriptionDoc,
  type PaymentDoc,
} from './types.js';

export async function subscriptionRoutes(app: FastifyInstance) {
  // Get subscription by userId
  app.get('/subscriptions/:userId', async req => {
    const { userId } = req.params as { userId: string };
    const sub = await repo.getByUserId(userId);
    if (!sub) throw new NotFoundError('Subscription not found');
    return sub;
  });

  // Create subscription
  app.post('/subscriptions', async (req, reply) => {
    const parsed = CreateSubscriptionSchema.safeParse(req.body);
    if (!parsed.success) {
      throw new BadRequestError(parsed.error.issues.map(i => i.message).join('; '));
    }
    const input = parsed.data;
    const now = new Date();
    const periodEnd = new Date(now);
    if (input.trialDays && input.trialDays > 0) {
      periodEnd.setDate(periodEnd.getDate() + input.trialDays);
    } else {
      periodEnd.setMonth(periodEnd.getMonth() + 1);
    }

    const doc: SubscriptionDoc = {
      id: `sub_${input.userId}_${Date.now()}`,
      productId: PRODUCT_ID,
      userId: input.userId,
      plan: input.plan,
      status: input.status,
      currentPeriodStart: now.toISOString(),
      currentPeriodEnd: periodEnd.toISOString(),
      cancelAtPeriodEnd: false,
      monthlyPrice: input.monthlyPrice,
      tokensIncluded: input.tokensIncluded,
      tokensUsed: 0,
      ...(input.stripeCustomerId && { stripeCustomerId: input.stripeCustomerId }),
      ...(input.stripeSubscriptionId && { stripeSubscriptionId: input.stripeSubscriptionId }),
      createdAt: now.toISOString(),
      updatedAt: now.toISOString(),
    };
    const created = await repo.createSubscription(doc);
    reply.code(201);
    return created;
  });

  // Update subscription by userId (looks up subscription, then updates)
  app.put('/subscriptions/:userId', async req => {
    const { userId } = req.params as { userId: string };

    const parsed = UpdateSubscriptionSchema.safeParse(req.body);
    if (!parsed.success) {
      throw new BadRequestError(parsed.error.issues.map(i => i.message).join('; '));
    }
    const existing = await repo.getByUserId(userId);
    if (!existing) throw new NotFoundError('Subscription not found');
    const updated = await repo.updateSubscription(existing.id, userId, parsed.data);
    if (!updated) throw new NotFoundError('Subscription update failed');
    return updated;
  });

  // List payments
  app.get('/payments/:userId', async req => {
    const { userId } = req.params as { userId: string };
    const { limit = '50' } = req.query as { limit?: string };
    return { payments: await repo.getPaymentsByUser(userId, Number(limit)) };
  });

  // Create payment
  app.post('/payments', async (req, reply) => {
    const parsed = CreatePaymentSchema.safeParse(req.body);
    if (!parsed.success) {
      throw new BadRequestError(parsed.error.issues.map(i => i.message).join('; '));
    }
    const input = parsed.data;
    const doc: PaymentDoc = {
      id: `pay_${crypto.randomUUID()}`,
      productId: PRODUCT_ID,
      ...input,
      createdAt: new Date().toISOString(),
    };
    const created = await repo.createPayment(doc);
    reply.code(201);
    return created;
  });
}