import { FastifyInstance } from 'fastify';
import { prisma } from '../../config/database.js';
import { apiKeyMiddleware } from '../middleware/apiKey.middleware.js';
import { linkUserSchema, paginationSchema } from '../middleware/validate.js';
import { successResponse, errorResponse, paginatedResponse, normalizeIgUsername } from '../../utils/helpers.js';

export async function integrationRoutes(app: FastifyInstance) {
  // All integration routes use API Key auth (for external e-commerce sites)
  app.addHook('preHandler', apiKeyMiddleware);

  // GET /api/v1/integration/cart-events
  app.get('/cart-events', async (request, reply) => {
    const { page, limit } = paginationSchema.parse(request.query);
    const tenantId = request.tenantId!;
    const skip = (page - 1) * limit;

    const query = request.query as { status?: string };

    const where: any = { tenantId };
    if (query.status) where.status = query.status;

    const [events, total] = await Promise.all([
      prisma.cartEvent.findMany({
        where,
        skip,
        take: limit,
        orderBy: { createdAt: 'desc' },
        include: {
          bid: {
            select: {
              igUsername: true,
              amount: true,
              bidType: true,
            },
          },
          auctionItem: {
            include: {
              product: {
                select: {
                  externalId: true,
                  name: true,
                  price: true,
                  imageUrl: true,
                  currency: true,
                },
              },
            },
          },
          user: {
            select: {
              igUsername: true,
              email: true,
              displayName: true,
              externalUserId: true,
            },
          },
        },
      }),
      prisma.cartEvent.count({ where }),
    ]);

    return paginatedResponse(reply, events, total, page, limit);
  });

  // POST /api/v1/integration/confirm
  app.post('/confirm', async (request, reply) => {
    const { cartEventId, externalCartId } = request.body as {
      cartEventId: string;
      externalCartId?: string;
    };

    if (!cartEventId) {
      return errorResponse(reply, 'cartEventId is required', 400);
    }

    const event = await prisma.cartEvent.findFirst({
      where: { id: cartEventId, tenantId: request.tenantId! },
    });
    if (!event) return errorResponse(reply, 'Cart event not found', 404);

    const updated = await prisma.cartEvent.update({
      where: { id: cartEventId },
      data: {
        status: 'confirmed',
        externalCartId,
        confirmedAt: new Date(),
      },
    });

    // Update user stats
    if (event.userId) {
      await prisma.user.update({
        where: { id: event.userId },
        data: { totalPurchases: { increment: 1 } },
      });
    }

    return successResponse(reply, updated);
  });

  // POST /api/v1/integration/users/link
  app.post('/users/link', async (request, reply) => {
    const parsed = linkUserSchema.safeParse(request.body);
    if (!parsed.success) {
      return errorResponse(reply, 'Validation error', 400, parsed.error.flatten());
    }

    const tenantId = request.tenantId!;
    const igUsername = normalizeIgUsername(parsed.data.igUsername);

    const user = await prisma.user.upsert({
      where: { tenantId_igUsername: { tenantId, igUsername } },
      update: {
        email: parsed.data.email,
        displayName: parsed.data.displayName,
        externalUserId: parsed.data.externalUserId,
        isVerified: true,
      },
      create: {
        tenantId,
        igUsername,
        igAuthMethod: 'manual',
        email: parsed.data.email,
        displayName: parsed.data.displayName ?? igUsername,
        externalUserId: parsed.data.externalUserId,
        isVerified: true,
      },
    });

    // Mark all unmatched bids from this user as matched
    await prisma.bid.updateMany({
      where: { igUsername, isMatched: false },
      data: { isMatched: true, userId: user.id },
    });

    return successResponse(reply, user, 201);
  });
}