mqsrv/src/routes/schemesAob.ts

import { Router, Request, Response } from 'express';
import { z } from 'zod';
import { authMiddleware, optionalAuth } from '../middleware/auth';
import { encrypt, encryptResponse } from '../utils/encryption';
import { prisma } from '../utils/prisma';

const router = Router();

function formatScheme(s: any) {
  return {
    id: s.id,
    user_id: s.userId,
    description: s.description || '',
    scheme_content: s.schemeContent || '',
    category: s.category || '',
    weapon_name: s.weaponName || '',
    tags: [],
    likes: s.likesCount ?? null,
    uses: s.downloadsCount || 0,
    status: s.status === 'PUBLISHED' ? 'normal' : null,
    comments: null,
    shares: null,
    created_at: s.createdAt?.toISOString?.() || s.createdAt,
    updated_at: s.updatedAt?.toISOString?.() || s.updatedAt,
    source: s.source ?? null,
    total_historical_uses: s.downloadsCount || 0,
    username: s.user?.username || s.username || '',
    avatar: s.user?.avatar || s.avatar || 'https://tuku.maqt.top/i/2026/03/22/sv3fg9.png',
    partner_type: null,
    partner_level: null,
    partner_badge: null,
    partner_logo: null,
    social_link: null,
  };
}

// ============================================
// 获取方案列表
// ============================================
router.get('/', optionalAuth, async (req: Request, res: Response) => {
  try {
    const {
      page = '1',
      limit = '12',
      weaponCategory,
      weaponName,
      search,
      sort = 'hot',
    } = req.query;

    const pageNum = Math.max(1, parseInt(String(page)) || 1);
    const limitNum = Math.min(100, Math.max(1, parseInt(String(limit)) || 12));
    const skip = (pageNum - 1) * limitNum;

    const where: any = { status: 'PUBLISHED' };
    if (weaponCategory) where.category = String(weaponCategory);
    if (weaponName) where.weaponName = { contains: String(weaponName) };
    if (search) where.description = { contains: String(search) };

    let orderBy: any = { downloadsCount: 'desc' };
    if (sort === 'new') orderBy = { createdAt: 'desc' };

    const schemes = await prisma.schemeAob.findMany({
      where,
      orderBy,
      skip,
      take: limitNum + 1,
      include: {
        user: { select: { id: true, username: true, avatar: true } },
      },
    });

    const hasMore = schemes.length > limitNum;
    const data = schemes.slice(0, limitNum).map(formatScheme);

    const payload = {
      success: true,
      data,
      pagination: { page: pageNum, limit: limitNum, hasMore },
    };

    if (req.query.encrypted === '1') {
      res.json(encryptResponse(payload));
    } else {
      res.json(payload);
    }
  } catch (error) {
    console.error('Get schemes_aob error:', error);
    res.status(500).json({ success: false, message: '获取失败' });
  }
});

// ============================================
// 获取单个方案
// ============================================
router.get('/:id', optionalAuth, async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const scheme = await prisma.schemeAob.findUnique({
      where: { id },
      include: { user: { select: { id: true, username: true, avatar: true } } },
    });

    if (!scheme || (scheme.status !== 'PUBLISHED' && scheme.userId !== req.user?.userId)) {
      return res.status(404).json({ success: false, message: '方案不存在' });
    }

    await prisma.schemeAob.update({
      where: { id },
      data: { viewsCount: { increment: 1 } },
    });

    let isFavorited = false;
    if (req.user) {
      const fav = await prisma.favorite.findFirst({
        where: { userId: req.user.userId, targetType: 'SCHEME_AOB', targetId: id },
      });
      isFavorited = !!fav;
    }

    res.json({
      success: true,
      data: { ...formatScheme(scheme), scheme_content: encrypt(scheme.schemeContent), isFavorited },
    });
  } catch (error) {
    console.error('Get scheme_aob error:', error);
    res.status(500).json({ success: false, message: '获取失败' });
  }
});

// ============================================
// 创建方案
// ============================================
const createSchema = z.object({
  description: z.string().min(1).max(50),
  category: z.string().optional(),
  weaponName: z.string().optional(),
  scheme: z.string().min(1),
  tags: z.array(z.string()).optional().default([]),
});

router.post('/', authMiddleware, async (req: Request, res: Response) => {
  try {
    const body = createSchema.parse(req.body);
    const scheme = await prisma.schemeAob.create({
      data: {
        userId: req.user!.userId,
        description: body.description,
        weaponName: body.weaponName,
        category: body.category,
        schemeContent: body.scheme,
        status: 'PUBLISHED',
      },
      include: {
        user: { select: { id: true, username: true, avatar: true } },
      },
    });

    await prisma.user.update({
      where: { id: req.user!.userId },
      data: { schemesCount: { increment: 1 } },
    });

    res.json({ success: true, message: '方案发布成功', data: formatScheme(scheme) });
  } catch (error) {
    console.error('Create scheme_aob error:', error);
    res.status(500).json({ success: false, message: '发布失败' });
  }
});

// ============================================
// 删除方案
// ============================================
router.delete('/:id', authMiddleware, async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const scheme = await prisma.schemeAob.findUnique({ where: { id }, select: { userId: true } });
    if (!scheme) return res.status(404).json({ success: false, message: '方案不存在' });
    if (scheme.userId !== req.user!.userId) return res.status(403).json({ success: false, message: '无权删除' });

    await prisma.schemeAob.update({ where: { id }, data: { status: 'DELETED' } });
    await prisma.user.update({ where: { id: req.user!.userId }, data: { schemesCount: { decrement: 1 } } });

    res.json({ success: true, message: '方案已删除' });
  } catch (error) {
    console.error('Delete scheme_aob error:', error);
    res.status(500).json({ success: false, message: '删除失败' });
  }
});

// ============================================
// 记录使用
// ============================================
router.post('/:id/use', optionalAuth, async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const scheme = await prisma.schemeAob.findUnique({ where: { id }, select: { id: true } });
    if (!scheme) return res.status(404).json({ success: false, message: '方案不存在' });

    await prisma.schemeAob.update({ where: { id }, data: { downloadsCount: { increment: 1 } } });

    if (req.user) {
      await prisma.userLog.create({
        data: { userId: req.user.userId, action: 'SchemeAobUse', targetType: 'SchemeAob', targetId: id },
      });
    }

    res.json({ success: true, message: '使用次数已记录' });
  } catch (error) {
    console.error('Scheme AOB use error:', error);
    res.status(500).json({ success: false, message: '记录失败' });
  }
});

// 举报
router.post('/:id/report', authMiddleware, async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const scheme = await prisma.schemeAob.findUnique({ where: { id }, select: { id: true } });
    if (!scheme) return res.status(404).json({ success: false, message: '方案不存在' });

    await prisma.userLog.create({
      data: { userId: req.user!.userId, action: 'Report', targetType: 'SchemeAob', targetId: id },
    });

    res.json({ success: true, message: '举报成功' });
  } catch (error) {
    console.error('Report scheme_aob error:', error);
    res.status(500).json({ success: false, message: '举报失败' });
  }
});

export default router;