// Express.js + express-session + Redis 연동
const express = require('express');
const session = require('express-session');
const RedisStore = require('connect-redis').default;
const { createClient } = require('redis');

const redisClient = createClient({ url: 'redis://localhost:6379' });
redisClient.connect();

const app = express();

app.use(session({
  store: new RedisStore({ client: redisClient }),
  secret: process.env.SESSION_SECRET, // 환경변수로 관리!
  resave: false,
  saveUninitialized: false,
  cookie: {
    secure: process.env.NODE_ENV === 'production', // HTTPS에서만 전송
    httpOnly: true,  // JS에서 접근 불가 (XSS 방어)
    sameSite: 'strict', // CSRF 방어
    maxAge: 1000 * 60 * 60 * 24 * 7 // 7일
  }
}));

// 장바구니 세션 초기화 미들웨어
app.use((req, res, next) => {
  if (!req.session.cartKey) {
    req.session.cartKey = generateSessionKey();
  }
  next();
});

// JWT 기반 인증 + 장바구니 연동
const jwt = require('jsonwebtoken');

// 토큰 생성
function generateTokens(userId) {
  const accessToken = jwt.sign(
    { userId, type: 'access' },
    process.env.JWT_SECRET,
    { expiresIn: '15m' } // 짧은 만료 시간
  );
  
  const refreshToken = jwt.sign(
    { userId, type: 'refresh' },
    process.env.JWT_REFRESH_SECRET,
    { expiresIn: '7d' }
  );
  
  return { accessToken, refreshToken };
}

// 장바구니 API 미들웨어
async function cartAuthMiddleware(req, res, next) {
  const token = req.headers.authorization?.split(' ')[1];
  
  if (token) {
    try {
      const decoded = jwt.verify(token, process.env.JWT_SECRET);
      req.userId = decoded.userId;
      req.isAuthenticated = true;
    } catch (err) {
      // 토큰 만료 → 비로그인으로 처리
      req.isAuthenticated = false;
    }
  }
  
  // 비로그인이면 쿠키에서 임시 세션 키 사용
  if (!req.isAuthenticated) {
    req.cartKey = req.cookies.cart_session || generateSessionKey();
    res.cookie('cart_session', req.cartKey, {
      httpOnly: true,
      maxAge: 1000 * 60 * 60 * 24 * 30 // 30일
    });
  }
  
  next();
}

// 장바구니 병합 서비스 (TypeScript)
class CartMergeService {
  
  async mergeOnLogin(
    guestCartKey: string,  // 비로그인 장바구니 키
    userId: number         // 로그인한 사용자 ID
  ): Promise<void> {
    
    // 1. 비로그인 장바구니 아이템 조회
    const guestItems = await CartItem.findAll({
      where: { 
        cartKey: guestCartKey,
        status: 'active'
      }
    });
    
    if (guestItems.length === 0) return; // 병합할 게 없으면 종료
    
    // 2. 사용자의 기존 장바구니 조회 (없으면 생성)
    let userCart = await Cart.findOne({ 
      where: { userId, status: 'active' }
    });
    
    if (!userCart) {
      userCart = await Cart.create({ userId, status: 'active' });
    }
    
    // 3. 트랜잭션으로 병합 처리
    await sequelize.transaction(async (t) => {
      for (const guestItem of guestItems) {
        
        // 기존 사용자 장바구니에 같은 상품+옵션이 있는지 확인
        const existingItem = await CartItem.findOne({
          where: {
            cartId: userCart.id,
            productId: guestItem.productId,
            variantId: guestItem.variantId
          },
          transaction: t
        });
        
        if (existingItem) {
          // 중복 상품: 수량 합산 (재고 초과 방지)
          const maxQty = await this.getMaxAvailableQty(guestItem.productId, guestItem.variantId);
          const mergedQty = Math.min(
            existingItem.quantity + guestItem.quantity,
            maxQty
          );
          
          await existingItem.update(
            { quantity: mergedQty },
            { transaction: t }
          );
        } else {
          // 새 상품: 사용자 장바구니에 추가
          await CartItem.create({
            cartId: userCart.id,
            productId: guestItem.productId,
            variantId: guestItem.variantId,
            quantity: guestItem.quantity,
            unitPrice: guestItem.unitPrice
          }, { transaction: t });
        }
        
        // 비로그인 아이템 삭제
        await guestItem.destroy({ transaction: t });
      }
      
      // 비로그인 장바구니 상태 변경
      await Cart.update(
        { status: 'merged' },
        { where: { sessionKey: guestCartKey }, transaction: t }
      );
    });
  }
  
  private async getMaxAvailableQty(productId: number, variantId: number): Promise<number> {
    const variant = await ProductVariant.findByPk(variantId);
    return variant ? variant.stockQty : 0;
  }
}

// Redis 기반 장바구니 캐싱 전략
class CartCacheService {
  private redis: Redis;
  private CACHE_TTL = 3600; // 1시간
  
  // 캐시 키 생성
  private getCacheKey(identifier: string): string {
    return `cart:${identifier}`;
  }
  
  // 장바구니 조회 (캐시 우선)
  async getCart(identifier: string): Promise<CartData | null> {
    const cacheKey = this.getCacheKey(identifier);
    
    // 1. Redis에서 먼저 조회
    const cached = await this.redis.get(cacheKey);
    if (cached) {
      return JSON.parse(cached); // 캐시 히트!
    }
    
    // 2. 캐시 미스 → DB에서 조회
    const cartData = await this.fetchFromDB(identifier);
    
    // 3. Redis에 캐싱
    if (cartData) {
      await this.redis.setex(
        cacheKey,
        this.CACHE_TTL,
        JSON.stringify(cartData)
      );
    }
    
    return cartData;
  }
  
  // 장바구니 수정 시 캐시 무효화
  async invalidateCart(identifier: string): Promise<void> {
    const cacheKey = this.getCacheKey(identifier);
    await this.redis.del(cacheKey);
  }
  
  // 장바구니 아이템 수 (빠른 조회용)
  async getCartCount(identifier: string): Promise<number> {
    const countKey = `cart:count:${identifier}`;
    const count = await this.redis.get(countKey);
    
    if (count !== null) return parseInt(count);
    
    // DB에서 집계
    const dbCount = await CartItem.count({
      where: { cartKey: identifier, status: 'active' }
    });
    
    await this.redis.setex(countKey, 300, dbCount.toString()); // 5분 캐시
    return dbCount;
  }
}

// Redis Hash 방식 - 아이템별 개별 관리
async function addToCartRedis(cartKey: string, item: CartItem) {
  const hashKey = `cart:hash:${cartKey}`;
  const fieldKey = `${item.productId}:${item.variantId || 'default'}`;
  
  // HSET으로 개별 아이템 저장
  await redis.hset(hashKey, fieldKey, JSON.stringify({
    productId: item.productId,
    variantId: item.variantId,
    quantity: item.quantity,
    unitPrice: item.unitPrice,
    addedAt: new Date().toISOString()
  }));
  
  // TTL 갱신
  await redis.expire(hashKey, 86400 * 30); // 30일
}

async function getCartFromRedis(cartKey: string) {
  const hashKey = `cart:hash:${cartKey}`;
  const allItems = await redis.hgetall(hashKey);
  
  if (!allItems) return [];
  
  return Object.values(allItems).map(item => JSON.parse(item));
}

// 수량만 업데이트 (전체 재조회 없이)
async function updateQuantityRedis(
  cartKey: string, 
  productId: number, 
  variantId: number, 
  newQty: number
) {
  const hashKey = `cart:hash:${cartKey}`;
  const fieldKey = `${productId}:${variantId || 'default'}`;
  
  const existing = await redis.hget(hashKey, fieldKey);
  if (existing) {
    const item = JSON.parse(existing);
    item.quantity = newQty;
    await redis.hset(hashKey, fieldKey, JSON.stringify(item));
  }
}

-- 낙관적 잠금을 위한 version 컬럼 추가
ALTER TABLE product_variant ADD COLUMN version INT DEFAULT 0;

-- 재고 차감 시 version 체크
UPDATE product_variant
SET 
  stock_qty = stock_qty - ?,
  version = version + 1
WHERE 
  variant_id = ?
  AND stock_qty >= ?      -- 재고 충분한지 확인
  AND version = ?;        -- 버전이 일치하는지 확인

-- 영향받은 행이 0이면 → 동시 수정 발생 → 재시도 또는 실패 처리

// 낙관적 잠금 구현 (Node.js)
async function decreaseStock(
  variantId: number, 
  quantity: number, 
  maxRetries: number = 3
): Promise<boolean> {
  
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    // 현재 재고와 버전 조회
    const variant = await ProductVariant.findByPk(variantId);
    
    if (!variant || variant.stockQty < quantity) {
      throw new Error('재고 부족');
    }
    
    // 낙관적 잠금으로 업데이트
    const [affectedRows] = await ProductVariant.update(
      {
        stockQty: variant.stockQty - quantity,
        version: variant.version + 1
      },
      {
        where: {
          variantId,
          version: variant.version, // 버전 일치 조건
          stockQty: { [Op.gte]: quantity }
        }
      }
    );
    
    if (affectedRows > 0) {
      return true; // 성공!
    }
    
    // 실패 → 잠시 대기 후 재시도 (지수 백오프)
    await sleep(Math.pow(2, attempt) * 100);
  }
  
  throw new Error('재고 처리 실패 - 재시도 초과');
}

// Redis Redlock을 활용한 분산 잠금
const Redlock = require('redlock');
const redlock = new Redlock([redis], {
  retryCount: 3,
  retryDelay: 200,
  retryJitter: 100
});

async function processCartCheckout(cartId: number, userId: number) {
  const lockKey = `lock:cart:${cartId}`;
  
  // 분산 잠금 획득 (5초 TTL)
  const lock = await redlock.acquire([lockKey], 5000);
  
  try {
    // 잠금 획득 성공 → 안전하게 처리
    const cartItems = await getCartItems(cartId);
    
    for (const item of cartItems) {
      // 재고 재확인
      const available = await checkStock(item.variantId, item.quantity);
      if (!available) {
        throw new Error(`${item.productName} 재고 부족`);
      }
    }
    
    // 주문 생성 및 재고 차감
    await createOrder(userId, cartItems);
    await clearCart(cartId);
    
  } finally {
    // 반드시 잠금 해제!
    await lock.release();
  }
}

// 장바구니 조회 응답 예시
{
  "success": true,
  "data": {
    "cartId": "cart_lq3k2m_a1b2c3d4",
    "userId": 12345,
    "items": [
      {
        "itemId": 1001,
        "product": {
          "id": 501,
          "name": "프리미엄 무선 이어폰",
          "thumbnail": "https://cdn.example.com/products/501.jpg",
          "currentPrice": 89000,  // 현재 가격
          "isAvailable": true
        },
        "variant": {
          "id": 201,
          "color": "블랙",
          "size": null,
          "stockQty": 15
        },
        "quantity": 2,
        "unitPrice": 89000,       // 담을 당시 가격
        "subtotal": 178000,
        "priceChanged": false,    // 가격 변동 여부
        "addedAt": "2024-01-15T10:30:00Z"
      }
    ],
    "summary": {
      "itemCount": 1,
      "totalQuantity": 2,
      "subtotal": 178000,
      "shippingFee": 0,
      "discount": 0,
      "total": 178000
    },
    "warnings": []  // 품절, 가격변동 등 경고
  }
}

// 결제 전 장바구니 검증 서비스
class CartValidationService {
  
  async validateBeforeCheckout(cartId: string, userId: number) {
    const cart = await this.getCartWithItems(cartId);
    const warnings: ValidationWarning[] = [];
    const errors: ValidationError[] = [];
    
    for (const item of cart.items) {
      // 1. 상품 활성화 상태 확인
      const product = await Product.findByPk(item.productId);
      if (!product || !product.isActive) {
        errors.push({
          type: 'PRODUCT_UNAVAILABLE',
          itemId: item.id,
          message: `${item.productName}은(는) 더 이상 판매하지 않습니다.`
        });
        continue;
      }
      
      // 2. 재고 확인
      const variant = await ProductVariant.findByPk(item.variantId);
      if (!variant || variant.stockQty < item.quantity) {
        if (variant && variant.stockQty > 0) {
          // 부분 재고 있음
          warnings.push({
            type: 'INSUFFICIENT_STOCK',
            itemId: item.id,
            message: `재고가 ${variant.stockQty}개만 남았습니다.`,
            availableQty: variant.stockQty
          });
        } else {
          // 완전 품절
          errors.push({
            type: 'OUT_OF_STOCK',
            itemId: item.id,
            message: `${item.productName}이(가) 품절되었습니다.`
          });
        }
      }
      
      // 3. 가격 변동 확인
      if (product.currentPrice !== item.unitPrice) {
        warnings.push({
          type: 'PRICE_CHANGED',
          itemId: item.id,
          message: `가격이 변경되었습니다.`,
          oldPrice: item.unitPrice,
          newPrice: product.currentPrice
        });
      }
      
      // 4. 구매 수량 제한 확인
      if (product.maxPurchaseQty && item.quantity > product.maxPurchaseQty) {
        errors.push({
          type: 'QUANTITY_LIMIT_EXCEEDED',
          itemId: item.id,
          message: `최대 ${product.maxPurchaseQty}개까지 구매 가능합니다.`
        });
      }
    }
    
    return {
      isValid: errors.length === 0,
      canProceed: errors.length === 0,
      errors,
      warnings,
      updatedSummary: await this.recalculateSummary(cart)
    };
  }
}

// React + Optimistic UI 예시
function useCartOptimistic() {
  const [cartItems, setCartItems] = useState([]);
  const [pendingItems, setPendingItems] = useState(new Set());
  
  const addToCart = async (product) => {
    const tempId = `temp_${Date.now()}`;
    
    // 1. 즉시 UI 업데이트 (낙관적)
    setCartItems(prev => [...prev, {
      ...product,
      id: tempId,
      isPending: true
    }]);
    
    setPendingItems(prev => new Set([...prev, tempId]));
    
    try {
      // 2. 서버 요청
      const response = await cartAPI.addItem(product);
      
      // 3. 성공: 임시 ID를 실제 ID로 교체
      setCartItems(prev => prev.map(item => 
        item.id === tempId 
          ? { ...response.data, isPending: false }
          : item
      ));
      
    } catch (error) {
      // 4. 실패: 롤백
      setCartItems(prev => prev.filter(item => item.id !== tempId));
      showToast('장바구니 추가에 실패했습니다. 다시 시도해주세요.');
      
    } finally {
      setPendingItems(prev => {
        const next = new Set(prev);
        next.delete(tempId);
        return next;
      });
    }
  };
  
  return { cartItems, addToCart, pendingItems };
}

// WebSocket을 활용한 실시간 재고 알림
// 서버 (Node.js + Socket.io)
io.on('connection', (socket) => {
  
  // 장바구니 아이템 구독
  socket.on('subscribe:cart', async (cartItems) => {
    const productIds = cartItems.map(item => item.productId);
    
    // 각 상품의 재고 변화 구독
    productIds.forEach(productId => {
      socket.join(`stock:${productId}`);
    });
  });
});

// 재고 변화 시 알림 발송
async function notifyStockChange(productId, newStock) {
  io.to(`stock:${productId}`).emit('stock:updated', {
    productId,
    stockQty: newStock,
    isLow: newStock <= 5,    // 5개 이하 = 품귀 임박
    isSoldOut: newStock === 0
  });
}

// 클라이언트 (React)
useEffect(() => {
  const socket = io(process.env.REACT_APP_WS_URL);
  
  socket.emit('subscribe:cart', cartItems);
  
  socket.on('stock:updated', ({ productId, stockQty, isSoldOut }) => {
    if (isSoldOut) {
      showWarning(`장바구니의 상품이 품절되었습니다!`);
      updateCartItemStatus(productId, 'soldout');
    } else if (stockQty <= 5) {
      showInfo(`잔여 재고: ${stockQty}개`);
    }
  });
  
  return () => socket.disconnect();
}, [cartItems]);

// Express Rate Limiter - 장바구니 API 보호
const rateLimit = require('express-rate-limit');

// 장바구니 추가 제한 (분당 30회)
const cartAddLimiter = rateLimit({
  windowMs: 60 * 1000, // 1분
  max: 30,
  keyGenerator: (req) => {
    // IP + 세션 조합으로 키 생성
    return `${req.ip}:${req.session?.cartKey || 'anonymous'}`;
  },
  message: {
    error: 'TOO_MANY_REQUESTS',
    message: '요청이 너무 많습니다. 잠시 후 다시 시도해주세요.'
  },
  standardHeaders: true,
  legacyHeaders: false
});

// 결제 시도 제한 (시간당 10회)
const checkoutLimiter = rateLimit({
  windowMs: 60 * 60 * 1000, // 1시간
  max: 10,
  skipSuccessfulRequests: true // 성공한 요청은 카운트 제외
});

app.post('/api/cart/items', cartAddLimiter, addToCartHandler);
app.post('/api/checkout', checkoutLimiter, checkoutHandler);

// 장바구니 소유권 검증 미들웨어
async function verifyCartOwnership(req, res, next) {
  const { cartId } = req.params;
  
  const cart = await Cart.findByPk(cartId);
  
  if (!cart) {
    return res.status(404).json({ error: '장바구니를 찾을 수 없습니다.' });
  }
  
  // 로그인 사용자: userId 일치 확인
  if (req.userId && cart.userId !== req.userId) {
    return res.status(403).json({ error: '접근 권한이 없습니다.' });
  }
  
  // 비로그인 사용자: 세션 키 일치 확인
  if (!req.userId && cart.sessionKey !== req.session.cartKey) {
    return res.status(403).json({ error: '접근 권한이 없습니다.' });
  }
  
  req.cart = cart;
  next();
}

// 라우터에 적용
app.patch('/api/cart/items/:itemId', 
  cartAuthMiddleware, 
  verifyCartOwnership, 
  updateCartItemHandler
);

-- 장바구니 조회 성능을 위한 인덱스
CREATE INDEX idx_cart_user_status 
  ON cart(user_id, status);

CREATE INDEX idx_cart_session_status 
  ON cart(session_key, status);

CREATE INDEX idx_cart_item_cart 
  ON cart_item(cart_id);

CREATE INDEX idx_cart_item_product 
  ON cart_item(product_id, variant_id);

-- 만료된 비로그인 장바구니 정리를 위한 인덱스
CREATE INDEX idx_cart_expires 
  ON cart(expires_at, status);

-- 복합 인덱스로 커버링 쿼리 최적화
CREATE INDEX idx_cart_item_covering 
  ON cart_item(cart_id, product_id, variant_id, quantity, unit_price);

// 만료된 장바구니 정리 (Cron Job)
const cron = require('node-cron');

// 매일 새벽 3시에 실행
cron.schedule('0 3 * * *', async () => {
  console.log('🧹 장바구니 정리 배치 시작...');
  
  const thirtyDaysAgo = new Date();
  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
  
  // 1. 30일 이상 된 비로그인 장바구니 삭제
  const expiredCarts = await Cart.findAll({
    where: {
      userId: null,
      status: 'active',
      updatedAt: { [Op.lt]: thirtyDaysAgo }
    }
  });
  
  for (const cart of expiredCarts) {
    await CartItem.destroy({ where: { cartId: cart.id } });
    await cart.update({ status: 'abandoned' });
  }
  
  // 2. 이미 병합된 장바구니 아카이브
  await Cart.update(
    { status: 'archived' },
    { 
      where: { 
        status: 'merged',
        updatedAt: { [Op.lt]: thirtyDaysAgo }
      }
    }
  );
  
  console.log(`✅ 정리 완료: ${expiredCarts.length}개 장바구니 처리`);
});

// Redis 캐시 워밍업 (자주 조회되는 장바구니)
async function warmupCartCache() {
  const activeUsers = await getActiveUserIds(); // 최근 1시간 활성 사용자
  
  for (const userId of activeUsers) {
    const cart = await fetchCartFromDB(userId);
    if (cart) {
      await redis.setex(`cart:${userId}`, 3600, JSON.stringify(cart));
    }
  }
}

// 마이크로서비스 환경 - 이벤트 기반 장바구니 동기화
// 이벤트 발행 (Cart Service)
class CartEventPublisher {
  async publishCartUpdated(cartId: string, userId: number) {
    await messageQueue.publish('cart.updated', {
      cartId,
      userId,
      timestamp: new Date().toISOString(),
      action: 'ITEM_ADDED'
    });
  }
  
  async publishCartCheckedOut(cartId: string, orderId: string) {
    await messageQueue.publish('cart.checked_out', {
      cartId,
      orderId,
      timestamp: new Date().toISOString()
    });
  }
}

// 이벤트 구독 (Inventory Service)
messageQueue.subscribe('cart.checked_out', async (event) => {
  const { cartId, orderId } = event;
  
  // 재고 차감 처리
  const cartItems = await getCartItems(cartId);
  for (const item of cartItems) {
    await decreaseInventory(item.variantId, item.quantity);
  }
  
  // 재고 차감 완료 이벤트 발행
  await messageQueue.publish('inventory.decreased', { orderId });
});

// 이벤트 구독 (Notification Service)
messageQueue.subscribe('cart.updated', async (event) => {
  const { userId } = event;
  
  // 장바구니 업데이트 알림 (선택적)
  await sendPushNotification(userId, {
    title: '장바구니 업데이트',
    body: '장바구니에 새 상품이 추가되었습니다.'
  });
});