쿠폰/할인 로직

1. 정액 (5,000원 할인)
2. 정률 (10% 할인)
3. 무료 배송
4. 1+1 / N개 구매 시 1개 무료
5. 카테고리별·상품별
6. 첫 구매 한정
7. 신규 가입 한정

CREATE TABLE coupons (
  id UUID PRIMARY KEY,
  code VARCHAR UNIQUE NOT NULL,
  name VARCHAR NOT NULL,
  description TEXT,
  type VARCHAR NOT NULL,  -- 'fixed', 'percentage', 'free_shipping', 'bogo'
  value DECIMAL(10,2) NOT NULL,  -- 5000 또는 10 또는 100
  min_order_amount DECIMAL(10,0),
  max_discount DECIMAL(10,0),    -- 정률의 상한
  usage_limit INT,                -- 전체 사용 한도
  usage_per_user INT DEFAULT 1,
  applicable_to VARCHAR DEFAULT 'all',  -- all, categories, products
  applicable_ids UUID[],          -- 대상 카테고리·상품
  conditions JSONB,               -- { firstOrder: true, minQuantity: 2, ... }
  starts_at TIMESTAMP,
  expires_at TIMESTAMP,
  status VARCHAR DEFAULT 'active',
  created_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE coupon_redemptions (
  id UUID PRIMARY KEY,
  coupon_id UUID NOT NULL,
  user_id UUID NOT NULL,
  order_id UUID,
  amount_discounted DECIMAL(10,0),
  used_at TIMESTAMP DEFAULT NOW()
);

CREATE INDEX ON coupon_redemptions(coupon_id);
CREATE INDEX ON coupon_redemptions(user_id, coupon_id);

async function applyCoupon(
  userId: string,
  cartItems: CartItem[],
  subtotal: number,
  couponCode: string,
) {
  const coupon = await db.coupon.findUnique({
    where: { code: couponCode.toUpperCase() },
  });
  if (!coupon || coupon.status !== 'active') {
    throw new NotFoundError('Coupon not found');
  }

  // 1. 기간 검증
  const now = new Date();
  if (coupon.startsAt && now < coupon.startsAt) {
    throw new BadRequestError('Coupon not yet active');
  }
  if (coupon.expiresAt && now > coupon.expiresAt) {
    throw new BadRequestError('Coupon expired');
  }

  // 2. 사용량 검증
  if (coupon.usageLimit) {
    const totalUsed = await db.couponRedemption.count({ where: { couponId: coupon.id } });
    if (totalUsed >= coupon.usageLimit) {
      throw new ConflictError('Coupon fully redeemed');
    }
  }

  const userUsed = await db.couponRedemption.count({
    where: { couponId: coupon.id, userId },
  });
  if (userUsed >= coupon.usagePerUser) {
    throw new ConflictError('Already used');
  }

  // 3. 최소 주문금액
  if (coupon.minOrderAmount && subtotal < coupon.minOrderAmount) {
    throw new BadRequestError(`Minimum order: ₩${coupon.minOrderAmount.toLocaleString()}`);
  }

  // 4. 조건 검증 (firstOrder 등)
  if (coupon.conditions?.firstOrder) {
    const prevOrders = await db.order.count({
      where: { userId, status: { in: ['paid', 'completed'] } },
    });
    if (prevOrders > 0) throw new ConflictError('First order only');
  }

  // 5. 적용 가능 상품 필터
  const applicableItems = filterApplicable(cartItems, coupon);
  const applicableSubtotal = applicableItems.reduce((s, i) => s + i.unitPrice * i.quantity, 0);

  // 6. 할인액 계산
  let discount = 0;
  switch (coupon.type) {
    case 'fixed':
      discount = Math.min(coupon.value, applicableSubtotal);
      break;
    case 'percentage':
      discount = applicableSubtotal * (coupon.value / 100);
      if (coupon.maxDiscount) discount = Math.min(discount, coupon.maxDiscount);
      break;
    case 'free_shipping':
      discount = 0;  // 별도 처리
      break;
  }

  return {
    coupon,
    discount: Math.round(discount),
    applicableItems: applicableItems.map(i => i.id),
  };
}


function filterApplicable(items: CartItem[], coupon: Coupon): CartItem[] {
  if (coupon.applicableTo === 'all') return items;
  if (coupon.applicableTo === 'products') {
    return items.filter(i => coupon.applicableIds.includes(i.productId));
  }
  if (coupon.applicableTo === 'categories') {
    return items.filter(i => coupon.applicableIds.includes(i.categoryId));
  }
  return items;
}

const COUPON_STACKING_RULES = {
  // 동시 사용 가능
  free_shipping: ['fixed', 'percentage'],

  // 단독 사용
  fixed: [],
  percentage: [],
};


async function applyMultipleCoupons(userId: string, cart: any, codes: string[]) {
  if (codes.length > 2) throw new BadRequestError('Max 2 coupons');

  const coupons = await Promise.all(codes.map(c => applyCoupon(userId, cart.items, cart.subtotal, c)));

  // stacking 검증
  if (coupons.length === 2) {
    const [a, b] = coupons;
    const aAllows = COUPON_STACKING_RULES[a.coupon.type] ?? [];
    if (!aAllows.includes(b.coupon.type)) {
      throw new ConflictError('Cannot combine these coupons');
    }
  }

  return coupons;
}

async function findBestCoupon(userId: string, cart: any) {
  const eligibleCoupons = await db.coupon.findMany({
    where: {
      status: 'active',
      startsAt: { lte: new Date() },
      OR: [
        { expiresAt: null },
        { expiresAt: { gt: new Date() } },
      ],
    },
  });

  let best = null;
  let bestDiscount = 0;

  for (const coupon of eligibleCoupons) {
    try {
      const { discount } = await applyCoupon(userId, cart.items, cart.subtotal, coupon.code);
      if (discount > bestDiscount) {
        best = coupon;
        bestDiscount = discount;
      }
    } catch {
      // 적용 불가 → 무시
    }
  }

  return best;
}

async function placeOrder(orderId: string, couponId: string | null) {
  if (!couponId) return;

  return db.$transaction(async (tx) => {
    const order = await tx.order.findUnique({ where: { id: orderId } });
    await tx.couponRedemption.create({
      data: {
        couponId,
        userId: order!.userId,
        orderId,
        amountDiscounted: order!.discount,
      },
    });
  });
}


// 환불 시 — 쿠폰 복구
async function refundOrder(orderId: string) {
  const order = await db.order.findUnique({ where: { id: orderId } });
  await db.couponRedemption.deleteMany({ where: { orderId } });
  // → 사용자가 다시 사용 가능
}