The Liquidation Stakes — Hội nhóm có thời hạn và sự đánh đổi

// Pre-filter trước khi gọi LLM
function preFilter(content: string): number | null {
  if (content.trim().length < 10) return 0;
  if (/^[\p{Emoji}\s]+$/u.test(content)) return 0;
  if ((content.match(/https?:\/\//g)||[]).length > 3)
    return 0;
  return null; // pass to LLM
}

export async function judgePost(
  content: string,
  circleCtx: { name: string; description: string }
) {
  // 1. Pre-filter cheap checks
  const preScore = preFilter(content);
  if (preScore !== null)
    return { score: 0, hp: -3, exp: 0 };

  // 2. Content hash cache
  const hash = sha256(content.trim().toLowerCase());
  const cached = await redis.get(`judge:${hash}`);
  if (cached) return JSON.parse(cached);

  // 3. Call LLM
  const result = await llm.complete(JUDGE_PROMPT, {
    circleName: circleCtx.name,
    content
  });
  const { score } = JSON.parse(result);

  // 4. Map score → HP/EXP delta
  const hp = score >= 9 ? 5
           : score >= 7 ? 3
           : score >= 5 ? 1
           : score >= 3 ? 0
           : score >= 1 ? -1 : -3;
  const exp = score >= 9 ? 10
            : score >= 7 ? 6
            : score >= 5 ? 2 : 0;

  await redis.setEx(`judge:${hash}`, 3600,
    JSON.stringify({ score, hp, exp }));
  return { score, hp, exp };
}

const LEVEL_CONFIG = [
  { level: 1, expRequired: 0,    maxHp: 500,  drain: 10 },
  { level: 2, expRequired: 200,  maxHp: 650,  drain: 9  },
  { level: 3, expRequired: 500,  maxHp: 800,  drain: 8  },
  { level: 4, expRequired: 1000, maxHp: 950,  drain: 7  },
  { level: 5, expRequired: 2000, maxHp: 1000, drain: 6  },
];

export async function checkLevelUp(circleId: number) {
  await prisma.$transaction(async (tx) => {
    // SELECT FOR UPDATE — prevent race condition
    const energy = await tx.$queryRaw<CircleEnergy[]>
      `SELECT * FROM circle_energy
       WHERE circle_id = ${circleId}
       FOR UPDATE`;

    const { level, exp } = energy[0];
    const next = LEVEL_CONFIG[level]; // next level config
    if (!next || exp < next.expRequired) return;

    await tx.circleEnergy.update({
      where: { circleId },
      data: {
        level: { increment: 1 },
        max: next.maxHp,
        // current HP không đổi, chỉ max tăng
      }
    });

    // Level 5 → bật statusPeak
    if (next.level === 5) {
      await tx.circle.update({
        where: { id: circleId },
        data: { statusPeak: true }
      });
    }
    await notifyAllMembers(circleId, "LEVEL_UP");
  });
}

// Chạy mỗi giờ — cron "0 * * * *"
export async function drainEnergy() {
  const now = new Date();
  const oneHourAgo = new Date(now - 3_600_000);

  // Nhóm im lặng: lastPostAt cũ hơn 1h
  const silentCircles = await prisma.circle.findMany({
    where: {
      deletedAt: null,
      lastPostAt: { lt: oneHourAgo }
    },
    include: { circleEnergy: true }
  });

  for (const circle of silentCircles) {
    const e = circle.circleEnergy;
    const drainAmount = LEVEL_CONFIG[e.level - 1].drain;
    const newHp = Math.max(0, e.current - drainAmount);

    await prisma.circleEnergy.update({
      where: { circleId: circle.id },
      data: { current: newHp, lastDrainAt: now }
    });

    if (newHp === 0) {
      await triggerGroupDeath(circle.id);
    }
  }
}

export async function claimQuest(
  userId: string,
  questId: number
) {
  return prisma.$transaction(async (tx) => {
    // Idempotency: check đã claim chưa
    const log = await tx.userQuestLog.findUnique({
      where: {
        userId_questId_date: {
          userId, questId,
          date: todayICT()
        }
      }
    });

    if (!log?.completed)
      throw new Error("Quest chưa hoàn thành");
    if (log.claimedAt)
      throw new Error("Đã claim rồi"); // 409

    // Atomic: mark claimed + credit karma
    await tx.userQuestLog.update({
      where: { id: log.id },
      data: { claimedAt: new Date() }
    });
    await tx.karmaTransaction.create({
      data: {
        userId,
        delta: 1,
        reason: "QUEST_REWARD"
      }
    });
    await tx.userKarma.upsert({
      where: { userId },
      update: { karma: { increment: 1 } },
      create: { userId, karma: 1 }
    });

    return { karmaEarned: 1 };
  });
}

router.post("/:id/sacrifice", auth, async (req, res) => {
  const { karmaAmount } = req.body;
  const userId = req.user.id;

  if (!karmaAmount || karmaAmount < 1)
    return res.status(400).json({ error: "Invalid" });

  try {
    const result = await prisma.$transaction(async (tx) => {
      // SELECT FOR UPDATE on karma row
      const [karma] = await tx.$queryRaw<UserKarma[]>
        `SELECT * FROM user_karma
         WHERE user_id = ${userId} FOR UPDATE`;

      if (!karma || karma.karma < karmaAmount)
        throw new Error("INSUFFICIENT_KARMA");

      const hpGain = Math.min(karmaAmount * 10, 500);

      await Promise.all([
        tx.userKarma.update({
          where: { userId },
          data: { karma: { decrement: karmaAmount } }
        }),
        tx.circleEnergy.update({
          where: { circleId: req.params.id },
          data: { current: { increment: hpGain } }
        }),
        tx.karmaTransaction.create({
          data: { userId, delta: -karmaAmount,
                  reason: "BURN_FOR_CIRCLE",
                  circleId: parseInt(req.params.id) }
        }),
        tx.userRestriction.create({
          data: { userId, type: "POST_BAN",
                  expiresAt: new Date(Date.now() + 172_800_000) }
        }),
        tx.heroBadge.create({
          data: { userId, circleId: parseInt(req.params.id),
                  type: "KARMA_SACRIFICE" }
        })
      ]);
      return hpGain;
    });
    res.json({ hpGained: result });
  } catch (e) {
    if (e.message === "INSUFFICIENT_KARMA")
      return res.status(400).json({ error: e.message });
    res.status(409).json({ error: "Race condition" });
  }
});

export async function generateSoulStone(
  circleId: string
) {
  const circle = await prisma.circle.findUnique({
    where: { publicId: circleId },
    include: {
      circlePostQualityLogs: {
        orderBy: { score: "desc" },
        take: 10
      },
      circleMembers: true,
      circleEnergy: true,
      heroBadges: true
    }
  });

  const summary = await llm.complete(`
    Tóm tắt lịch sử nhóm "${circle.name}" thành văn bia ~100 chữ.
    Tập trung: đỉnh cao (HP ${circle.circleEnergy.peak}),
    level đạt được (${circle.circleEnergy.level}),
    lý do tử vong, di sản để lại.
    Văn phong trang trọng, bi tráng nhưng không bi thảm.
  `);

  await prisma.$transaction([
    prisma.circleSoulStone.create({
      data: {
        circleId, summary,
        peakHp: circle.circleEnergy.peak,
        livedDays: calcDays(circle.createdAt),
        topPostIds: circle.circlePostQualityLogs
          .map(p => p.postId)
      }
    }),
    prisma.circle.update({
      where: { publicId: circleId },
      data: { deletedAt: new Date() }
    })
  ]);
}

model DailyQuest {
  id          Int     @id @default(autoincrement())
  code        String  @unique // "DEEP_COMMENT"
  description String  @db.VarChar(255)
  karmaReward Int     @default(1)
  requirement Int     // số lần cần hoàn thành
  minScore    Int     // AI score threshold
  isActive    Boolean @default(true)

  questLogs   UserQuestLog[]
  @@map("daily_quests")
}

model UserQuestLog {
  id        Int       @id @default(autoincrement())
  userId    String    @map("user_id")
  questId   Int       @map("quest_id")
  progress  Int       @default(0)
  completed Boolean   @default(false)
  claimedAt DateTime? @map("claimed_at")
  date      DateTime  @db.Date // ICT date, reset key

  user  User       @relation(fields: [userId], references: [id])
  quest DailyQuest @relation(fields: [questId], references: [id])

  @@unique([userId, questId, date])
  @@index([userId, date])
  @@map("user_quest_logs")
}

model KarmaTransaction {
  id        Int         @id @default(autoincrement())
  userId    String      @map("user_id")
  delta     Int         // +1 quest, -5 đốt karma
  reason    KarmaReason
  circleId  Int?        @map("circle_id")
  createdAt DateTime    @default(now())

  user User @relation(fields: [userId], references: [id])
  @@index([userId])
  @@map("karma_transactions")
}

enum KarmaReason {
  QUEST_REWARD
  BURN_FOR_CIRCLE
}

model HeroBadge {
  id        Int       @id @default(autoincrement())
  userId    String    @map("user_id")
  circleId  Int       @map("circle_id")
  type      BadgeType
  createdAt DateTime  @default(now())

  user   User   @relation(fields: [userId], references: [id])
  circle Circle @relation(fields: [circleId], references: [id])
  @@index([userId])
  @@map("hero_badges")
}

enum BadgeType {
  KARMA_SACRIFICE // đốt karma cứu nhóm
  CPR_HERO        // comment trong CPR thành công
  FOUNDER         // người tạo nhóm
}

model CircleEnergy {
  id          Int      @id @default(autoincrement())
  circleId    Int      @map("circle_id") @unique
  level       Int      @default(1)
  exp         Int      @default(0)
  current     Int      @default(500)
  max         Int      @default(500)
  peak        Int      @default(500)

  // NEW fields:
  lastDrainAt DateTime? @map("last_drain_at")
  // Dùng để compensate nếu cron bị miss
  // Logic: (now - lastDrainAt) / 1h * drainRate

  createdAt   DateTime @default(now())
  updatedAt   DateTime @updatedAt

  circle Circle @relation(fields: [circleId], references: [id])
  @@index([circleId])
  @@map("circle_energy")
}

model CprSession {
  id             String   @id @default(cuid())
  circleId       String   // publicId of circle
  activatedBy    String   // userId of admin
  expiresAt      DateTime
  resolved       Boolean  @default(false)
  success        Boolean?

  // NEW fields:
  targetComments Int      @default(10)
  // ngưỡng deep-talk comments để CPR thành công
  currentComments Int     @default(0)
  // realtime count, tăng sau mỗi judge xong
  postId         Int?     // bài CPR cụ thể

  createdAt      DateTime @default(now())

  circle Circle @relation(
    fields: [circleId], references: [publicId])
  @@map("cpr_sessions")
}

// CircleExpLog thêm reason enum:
enum ExpReason {
  POST_QUALITY    // bài score 5+
  MEMBER_JOIN     // thành viên mới join
  CPR_SURVIVED    // sống sót qua CPR
  KARMA_SACRIFICE // có member đốt karma
}