import { Injectable, NotFoundException } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { PrismaService } from '../../common/prisma/prisma.module';
import { serializeBigInt } from '../../common/decorators/current-user.decorator';
import type { AdminDeliveriesQueryDto, AdminRedeemRecordsQueryDto } from './dto/admin-query.dto';
import type { UpdateDeliveryDto } from './dto/admin-mutate.dto';

@Injectable()
export class AdminRedeemService {
  constructor(private readonly prisma: PrismaService) {}

  async listRecords(query: AdminRedeemRecordsQueryDto) {
    const page = query.page ?? 1;
    const pageSize = query.pageSize ?? 20;
    const where: Prisma.RedeemRecordWhereInput = {};
    if (query.redeemNo) where.redeemNo = { contains: query.redeemNo };
    if (query.storeId) where.storeId = BigInt(query.storeId);
    if (query.userId) where.userId = BigInt(query.userId);

    const [items, total] = await Promise.all([
      this.prisma.redeemRecord.findMany({
        where,
        orderBy: { createdAt: 'desc' },
        skip: (page - 1) * pageSize,
        take: pageSize,
        include: {
          user: { select: { id: true, userNo: true, phone: true, nickname: true } },
          store: { select: { id: true, name: true, cityName: true } },
          coupon: { select: { id: true, couponNo: true, balance: true } },
        },
      }),
      this.prisma.redeemRecord.count({ where }),
    ]);
    return serializeBigInt({ items, total, page, pageSize });
  }

  async detailRecord(id: bigint) {
    const record = await this.prisma.redeemRecord.findUnique({
      where: { id },
      include: {
        user: true,
        store: { include: { partner: { select: { id: true, companyName: true } } } },
        coupon: true,
        payout: true,
        commissions: true,
      },
    });
    if (!record) throw new NotFoundException('核销记录不存在');
    return serializeBigInt(record);
  }
}

@Injectable()
export class AdminDeliveriesService {
  constructor(private readonly prisma: PrismaService) {}

  async list(query: AdminDeliveriesQueryDto) {
    const page = query.page ?? 1;
    const pageSize = query.pageSize ?? 20;
    const where: Prisma.OrderDeliveryWhereInput = {};
    if (query.provider) where.provider = query.provider;
    if (query.trackingNo) where.trackingNo = { contains: query.trackingNo };
    if (query.orderNo) {
      where.order = { orderNo: { contains: query.orderNo } };
    }

    const [items, total] = await Promise.all([
      this.prisma.orderDelivery.findMany({
        where,
        orderBy: { updatedAt: 'desc' },
        skip: (page - 1) * pageSize,
        take: pageSize,
        include: {
          order: {
            select: {
              id: true,
              orderNo: true,
              status: true,
              receiverName: true,
              receiverPhone: true,
              deliveryType: true,
            },
          },
        },
      }),
      this.prisma.orderDelivery.count({ where }),
    ]);
    return serializeBigInt({ items, total, page, pageSize });
  }

  async detail(id: bigint) {
    const delivery = await this.prisma.orderDelivery.findUnique({
      where: { id },
      include: {
        order: {
          include: {
            user: { select: { id: true, userNo: true, phone: true } },
            items: true,
          },
        },
      },
    });
    if (!delivery) throw new NotFoundException('配送单不存在');
    return serializeBigInt(delivery);
  }

  async update(id: bigint, dto: UpdateDeliveryDto) {
    const delivery = await this.prisma.orderDelivery.update({
      where: { id },
      data: {
        ...(dto.provider !== undefined ? { provider: dto.provider } : {}),
        ...(dto.providerOrderNo !== undefined ? { providerOrderNo: dto.providerOrderNo } : {}),
        ...(dto.trackingNo !== undefined ? { trackingNo: dto.trackingNo } : {}),
      },
      include: { order: { select: { orderNo: true, status: true } } },
    });
    return serializeBigInt(delivery);
  }
}