import dbConnect from "../../lib/dbConnect";
import ExchangeHistory from "../../models/ExchangeHistory";
import ExchangeItem from "../../models/ExchangeItem";
import User from "../../models/User";
import PointHistory from "../../models/PointHistory";
import { NextResponse } from "next/server";
import { setCORSHeaders, handleError } from "../../lib/apiUtils";

export async function GET(request) {
  await dbConnect();
  console.log("GET请求已接收");
  try {
    const { searchParams } = new URL(request.url);
    let query = {};
    let itemQuery = {};

    for (const [key, value] of searchParams.entries()) {
      switch (key) {
        case "username":
          query.username = { $regex: value, $options: "i" };
          break;
        case "userId":
          query.userId = value;
          break;
        case "item":
          try {
            const itemObj = JSON.parse(value);
            if (itemObj.title) {
              itemQuery.title = {
                $regex: itemObj.title,
                $options: "i",
              };
            }
            if (itemObj.type) {
              itemQuery.type = itemObj.type;
            }
          } catch (e) {
            console.error("Error parsing item JSON:", e);
          }
          break;
        case "status":
          query.status = value;
          break;
        case "exchangeTime":
          const [start, end] = value.split(",");
          query.exchangeTime = {
            $gte: new Date(start),
            $lte: new Date(end),
          };
          break;
      }
    }

    console.log("Query:", query);
    console.log("Item Query:", itemQuery);

    // 首先查找符合条件的 ExchangeItem
    const matchedItems = await ExchangeItem.find(itemQuery).select("_id");
    const itemIds = matchedItems.map((item) => item._id);

    // 将匹配的 item ID 添加到主查询中
    if (itemIds.length > 0) {
      query.item = { $in: itemIds };
    }

    const exchangeHistories = await ExchangeHistory.find(query).populate(
      "item",
      "title type points"
    );

    const message =
      exchangeHistories.length > 0
        ? "成功获取兑换历史"
        : "当前没有任何兑换历史";
    const response = NextResponse.json(
      {
        success: true,
        data: exchangeHistories,
        message,
        total: exchangeHistories.length,
      },
      { status: 200 }
    );
    return setCORSHeaders(response);
  } catch (error) {
    console.error("Error in GET /api/exchange-history:", error);
    return handleError(error);
  }
}

export async function POST(request) {
  await dbConnect();
  try {
    const {
      userId,
      username,
      item,
      status,
      exchangeInfo,
      exchangeTime,
      exchangeCount,
    } = await request.json();

    // 获取用户当前积分
    const user = await User.findById(userId);
    if (!user) {
      return setCORSHeaders(
        NextResponse.json(
          { success: false, error: "未找到用户" },
          { status: 404 }
        )
      );
    }

    const currentPoints = user.points;
    const pointsToDeduct = item.points;

    // 检查用户积分是否足够
    if (currentPoints < pointsToDeduct) {
      return setCORSHeaders(
        NextResponse.json(
          {
            success: false,
            error: "积分不足",
            currentPoints: currentPoints,
            requiredPoints: pointsToDeduct,
          },
          { status: 400 }
        )
      );
    }

    // 创建新的兑换历史记录
    const newExchangeHistory = new ExchangeHistory({
      userId,
      username,
      item,
      status,
      exchangeInfo,
      exchangeTime,
      exchangeCount,
    });
    await newExchangeHistory.save();

    // 更新用户积分
    const updatedUser = await User.findByIdAndUpdate(
      userId,
      { $inc: { points: -pointsToDeduct } },
      { new: true, runValidators: true }
    );

    if (!updatedUser) {
      throw new Error("更新用户积分失败");
    }

    console.log(
      `用户 ${updatedUser.username} 的积分已扣除 ${pointsToDeduct} 点`
    );

    // 创建积分加减历史记录
    const reason = `兑换: ${item.title.replace(/<[^>]*>/g, "").trim()}`;
    const pointHistory = new PointHistory({
      user: updatedUser._id,
      points: -pointsToDeduct,
      reason: reason,
    });
    await pointHistory.save();

    const response = NextResponse.json(
      {
        success: true,
        message: "兑换历史创建成功",
        data: newExchangeHistory,
      },
      { status: 201 }
    );
    return setCORSHeaders(response);
  } catch (error) {
    console.error("创建兑换历史时出错:", error);
    return handleError(error);
  }
}

export async function PUT(request) {
  await dbConnect();
  try {
    const { id, ...updateData } = await request.json();
    console.log(id, updateData);
    const updatedExchangeHistory = await ExchangeHistory.findByIdAndUpdate(
      id,
      updateData,
      {
        new: true,
        runValidators: true,
      }
    );
    if (!updatedExchangeHistory) {
      return NextResponse.json(
        { success: false, error: "未找到兑换历史" },
        { status: 404 }
      );
    }
    const response = NextResponse.json(
      { success: true, data: updatedExchangeHistory },
      { status: 200 }
    );
    return setCORSHeaders(response);
  } catch (error) {
    return handleError(error);
  }
}

export async function DELETE(request) {
  await dbConnect();
  try {
    const url = new URL(request.url);
    const id = url.searchParams.get("id");
    if (!id) {
      return NextResponse.json(
        { success: false, error: "需要提供兑换历史ID" },
        { status: 400 }
      );
    }
    const deletedExchangeHistory = await ExchangeHistory.findByIdAndDelete(id);
    if (!deletedExchangeHistory) {
      return NextResponse.json(
        { success: false, error: "未找到兑换历史" },
        { status: 404 }
      );
    }
    const response = NextResponse.json(
      { success: true, message: "兑换历史删除成功" },
      { status: 200 }
    );
    return setCORSHeaders(response);
  } catch (error) {
    return handleError(error);
  }
}

export async function OPTIONS() {
  const response = new NextResponse(null, { status: 204 });
  return setCORSHeaders(response);
}