import { NextResponse } from "next/server";
import { requireMembership } from "@/lib/blindbox";
import { apiHandler, ApiError } from "@/lib/api";
import { runPlanGeneration } from "@/lib/blindboxPlanGen";
import { getAuthUserId } from "@/lib/auth";

interface AvailableTime {
  date: string;
  startHour: number;
  endHour: number;
}

export const POST = apiHandler(async (req) => {
  const userId = await getAuthUserId(req);
  const { roomId, availableTime } = await req.json();

  if (!roomId) throw new ApiError("roomId 不能为空");

  await requireMembership(roomId, userId);

  const at = availableTime as AvailableTime;
  if (
    !at?.date ||
    typeof at.startHour !== "number" ||
    typeof at.endHour !== "number" ||
    at.endHour <= at.startHour
  ) {
    throw new ApiError("请选择有效的可用时间");
  }

  const result = await runPlanGeneration(roomId, userId, at);

  return NextResponse.json({
    id: result.id,
    days: result.days,
    createdAt: result.createdAt,
  });
});

/**
 * Map "周六"/"周日" to the next occurrence of that weekday from a reference date.
 * Returns a Date at 00:00 of that day.
 */
function nextWeekday(dayLabel: string, from: Date): Date {
  const targetDow = dayLabel === "周日" ? 0 : 6; // Sunday=0, Saturday=6
  const d = new Date(from);
  d.setHours(0, 0, 0, 0);
  const diff = (targetDow - d.getDay() + 7) % 7;
  d.setDate(d.getDate() + (diff === 0 ? 0 : diff));
  return d;
}

function computeEndTime(planData: string, now: Date): Date | null {
  try {
    const parsed = JSON.parse(planData);
    const days = parsed.days as { date: string; items: { time: string; duration: number }[] }[];
    if (!days?.length) return null;

    const lastDay = days[days.length - 1];
    const lastItem = lastDay.items[lastDay.items.length - 1];
    if (!lastItem) return null;

    const base = nextWeekday(lastDay.date, now);
    const [h, m] = lastItem.time.split(":").map(Number);
    base.setHours(h, m, 0, 0);
    base.setMinutes(base.getMinutes() + (lastItem.duration || 60));

    if (base.getTime() < now.getTime()) {
      base.setDate(base.getDate() + 7);
    }

    return base;
  } catch (e) {
    console.error("computeEndTime failed:", e);
    return null;
  }
}

export const PATCH = apiHandler(async (req) => {
  const userId = await getAuthUserId(req);
  const { planId, action, days } = await req.json();
  if (!planId) throw new ApiError("planId 不能为空");

  const { prisma } = await import("@/lib/prisma");
  const plan = await prisma.weekendPlan.findUnique({ where: { id: planId } });
  if (!plan) throw new ApiError("计划不存在", 404);
  if (plan.userId !== userId) throw new ApiError("只能操作自己的计划", 403);

  const act = action || "accept";

  if (act === "accept") {
    if (plan.status !== "active") throw new ApiError("该计划无法接受", 400);
    const endTime = computeEndTime(plan.planData, new Date());
    await prisma.weekendPlan.update({
      where: { id: planId },
      data: { status: "accepted", endTime },
    });
    return NextResponse.json({ ok: true, endTime });
  }

  if (act === "complete" || act === "expire") {
    if (plan.status !== "accepted") throw new ApiError("只能更新已接受的计划", 400);
    await prisma.weekendPlan.update({
      where: { id: planId },
      data: { status: act === "complete" ? "completed" : "expired" },
    });
    return NextResponse.json({ ok: true });
  }

  if (act === "update_plan") {
    if (plan.status !== "active" && plan.status !== "accepted") {
      throw new ApiError("只能编辑进行中的计划", 400);
    }
    if (!Array.isArray(days) || days.length === 0) {
      throw new ApiError("days 数据无效", 400);
    }
    const newPlanData = JSON.stringify({ days });
    await prisma.weekendPlan.update({
      where: { id: planId },
      data: {
        planData: newPlanData,
        ...(plan.status === "accepted"
          ? { endTime: computeEndTime(newPlanData, new Date()) }
          : {}),
      },
    });
    return NextResponse.json({ ok: true });
  }

  throw new ApiError("无效的操作", 400);
});

export const GET = apiHandler(async (req) => {
  const userId = await getAuthUserId(req);
  const { searchParams } = new URL(req.url);
  const mode = searchParams.get("mode") || "latest";

  const { prisma } = await import("@/lib/prisma");

  if (mode === "latest") {
    const roomId = searchParams.get("roomId");
    if (!roomId) throw new ApiError("roomId 不能为空");

    const plan = await prisma.weekendPlan.findFirst({
      where: { roomId, userId, status: "accepted" },
      orderBy: { createdAt: "desc" },
      select: { id: true, planData: true, endTime: true, createdAt: true },
    });

    if (!plan) return NextResponse.json({ plan: null });
    const parsed = JSON.parse(plan.planData);
    return NextResponse.json({
      plan: { id: plan.id, days: parsed.days, endTime: plan.endTime, createdAt: plan.createdAt },
    });
  }

  if (mode === "pending") {
    const plans = await prisma.weekendPlan.findMany({
      where: {
        userId,
        status: "accepted",
        endTime: { not: null, lt: new Date() },
      },
      orderBy: { createdAt: "desc" },
      select: { id: true, planData: true, roomId: true, createdAt: true },
      take: 5,
    });

    const result = await Promise.all(
      plans.map(async (p) => {
        const room = await prisma.blindBoxRoom.findUnique({
          where: { id: p.roomId },
          select: { name: true, code: true },
        });
        const parsed = JSON.parse(p.planData);
        const days = parsed.days as { date: string; items: { activity: string }[] }[];
        return {
          id: p.id,
          roomName: room?.name ?? "未知房间",
          roomCode: room?.code ?? "",
          date: days.map((d) => d.date).join(" + "),
          activities: days.flatMap((d) => d.items.map((i) => i.activity)),
          createdAt: p.createdAt,
        };
      }),
    );

    return NextResponse.json({ pending: result });
  }

  if (mode === "history") {
    const plans = await prisma.weekendPlan.findMany({
      where: {
        userId,
        status: { in: ["completed", "expired"] },
      },
      orderBy: { createdAt: "desc" },
      select: { id: true, planData: true, status: true, roomId: true, createdAt: true },
      take: 50,
    });

    const result = await Promise.all(
      plans.map(async (p) => {
        const room = await prisma.blindBoxRoom.findUnique({
          where: { id: p.roomId },
          select: { name: true, code: true },
        });
        const parsed = JSON.parse(p.planData);
        const days = parsed.days as { date: string; items: { activity: string }[] }[];
        return {
          id: p.id,
          status: p.status,
          roomName: room?.name ?? "未知房间",
          roomCode: room?.code ?? "",
          date: days.map((d) => d.date).join(" + "),
          dayCount: days.length,
          activities: days.flatMap((d) => d.items.map((i) => i.activity)),
          createdAt: p.createdAt,
        };
      }),
    );

    return NextResponse.json({ history: result });
  }

  throw new ApiError("无效的 mode 参数", 400);
});