generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

enum Role {
  READER
  AUTHOR
  ADMIN
}

enum TransactionType {
  DEPOSIT
  CHAPTER_UNLOCK
  DONATION
  DAILY_REWARD
  STREAK_REWARD
  VIP_PURCHASE
}

model User {
  id            String   @id @default(uuid())
  email         String   @unique
  passwordHash  String?
  fullName      String
  avatar        String?
  banner        String?
  bio           String?
  role          Role     @default(READER)
  
  // Economy & VIP
  coins         Int      @default(0)
  vipUntil      DateTime?
  
  // Gamification
  level         Int      @default(1)
  exp           Int      @default(0)
  currentStreak Int      @default(0)
  longestStreak Int      @default(0)
  lastReadAt    DateTime?
  lastCheckInAt DateTime?

  // Relations
  novels        Novel[]        @relation("AuthorNovels")
  bookmarks     Bookmark[]
  unlockedChapters UnlockedChapter[]
  transactions  Transaction[]
  checkIns      CheckInLog[]

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

model Novel {
  id          String   @id @default(uuid())
  title       String
  slug        String   @unique
  summary     String   @db.Text
  coverImage  String
  authorId    String
  author      User     @relation("AuthorNovels", fields: [authorId], references: [id])
  status      String   @default("ONGOING") // ONGOING, COMPLETED, PAUSED
  views       Int      @default(0)
  likes       Int      @default(0)
  
  chapters    Chapter[]
  categories  CategoryOnNovel[]

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

model Chapter {
  id          String   @id @default(uuid())
  novelId     String
  novel       Novel    @relation(fields: [novelId], references: [id], onDelete: Cascade)
  chapterNum  Float
  title       String
  content     String   @db.Text
  isVip       Boolean  @default(false)
  price       Int      @default(0)

  unlockedBy  UnlockedChapter[]

  createdAt   DateTime @default(now())
}

model UnlockedChapter {
  id        String   @id @default(uuid())
  userId    String
  user      User     @relation(fields: [userId], references: [id])
  chapterId String
  chapter   Chapter  @relation(fields: [chapterId], references: [id])

  createdAt DateTime @default(now())

  @@unique([userId, chapterId])
}

model Category {
  id     String            @id @default(uuid())
  name   String            @unique
  slug   String            @unique
  novels CategoryOnNovel[]
}

model CategoryOnNovel {
  novelId    String
  novel      Novel    @relation(fields: [novelId], references: [id])
  categoryId String
  category   Category @relation(fields: [categoryId], references: [id])

  @@id([novelId, categoryId])
}

model Transaction {
  id          String          @id @default(uuid())
  userId      String
  user        User            @relation(fields: [userId], references: [id])
  amount      Int             // Positive for credit, negative for debit
  type        TransactionType
  description String
  createdAt   DateTime        @default(now())
}

model CheckInLog {
  id        String   @id @default(uuid())
  userId    String
  user      User     @relation(fields: [userId], references: [id])
  dayCount  Int      // Số ngày điểm danh liên tiếp trong chu kỳ
  coinsEarned Int
  createdAt DateTime @default(now())
}

model Bookmark {
  userId    String
  user      User     @relation(fields: [userId], references: [id])
  novelId   String
  novel     Novel    @relation(fields: [novelId], references: [id])
  createdAt DateTime @default(now())

  @@id([userId, novelId])
}
// src/chapter/chapter.service.ts
import { Injectable, BadRequestException, ForbiddenException } from '@nestjs/common';
import { PrismaService } from '../prisma/prisma.service';

@Injectable()
export class ChapterService {
  constructor(private prisma: PrismaService) {}

  async unlockChapter(userId: string, chapterId: string) {
    const chapter = await this.prisma.chapter.findUnique({ where: { id: chapterId } });
    if (!chapter) throw new BadRequestException('Chương không tồn tại');
    if (!chapter.isVip) return { message: 'Chương này miễn phí' };

    const user = await this.prisma.user.findUnique({ where: { id: userId } });
    
    // Kiểm tra VIP còn hạn -> Giảm giá 20%
    const isVipActive = user?.vipUntil && new Date(user.vipUntil) > new Date();
    const finalPrice = isVipActive ? Math.floor(chapter.price * 0.8) : chapter.price;

    if ((user?.coins ?? 0) < finalPrice) {
      throw new ForbiddenException('Bạn không đủ xu để mở khóa chương này');
    }

    // Kiểm tra xem đã mở khóa chưa
    const existing = await this.prisma.unlockedChapter.findUnique({
      where: { userId_chapterId: { userId, chapterId } },
    });
    if (existing) return { message: 'Chương đã được mở khóa từ trước' };

    return await this.prisma.$transaction(async (tx) => {
      // Trừ xu user
      await tx.user.update({
        where: { id: userId },
        data: { coins: { decrement: finalPrice } },
      });

      // Tạo record đã unlock
      await tx.unlockedChapter.create({
        data: { userId, chapterId },
      });

      // Tạo nhật ký giao dịch
      await tx.transaction.create({
        data: {
          userId,
          amount: -finalPrice,
          type: 'CHAPTER_UNLOCK',
          description: `Mở khóa chương ${chapter.chapterNum}: ${chapter.title}`,
        },
      });

      return { success: true, pricePaid: finalPrice };
    });
  }
}
      // src/gamification/gamification.service.ts
import { Injectable, BadRequestException } from '@nestjs/common';
import { PrismaService } from '../prisma/prisma.service';

@Injectable()
export class GamificationService {
  constructor(private prisma: PrismaService) {}

  async dailyCheckIn(userId: string) {
    const user = await this.prisma.user.findUnique({ where: { id: userId } });
    if (!user) throw new BadRequestException('User không tồn tại');

    const today = new Date();
    today.setHours(0, 0, 0, 0);

    if (user.lastCheckInAt) {
      const lastCheckIn = new Date(user.lastCheckInAt);
      lastCheckIn.setHours(0, 0, 0, 0);
      if (lastCheckIn.getTime() === today.getTime()) {
        throw new BadRequestException('Hôm nay bạn đã điểm danh rồi!');
      }
    }

    // Tính ngày liên tiếp
    let streak = 1;
    if (user.lastCheckInAt) {
      const yesterday = new Date(today);
      yesterday.setDate(yesterday.getDate() - 1);
      const lastCheckIn = new Date(user.lastCheckInAt);
      lastCheckIn.setHours(0, 0, 0, 0);

      if (lastCheckIn.getTime() === yesterday.getTime()) {
        streak = (user.currentStreak % 30) + 1;
      }
    }

    // Công thức tính thưởng Xu
    const baseCoins = 20;
    const bonusCoins = Math.min(streak * 5, 100);
    const totalCoins = baseCoins + bonusCoins;

    return await this.prisma.$transaction(async (tx) => {
      // Cập nhật User
      const updatedUser = await tx.user.update({
        where: { id: userId },
        data: {
          coins: { increment: totalCoins },
          exp: { increment: 50 },
          currentStreak: streak,
          longestStreak: Math.max(streak, user.longestStreak),
          lastCheckInAt: new Date(),
        },
      });

      // Ghi nhật ký giao dịch
      await tx.transaction.create({
        data: {
          userId,
          amount: totalCoins,
          type: 'DAILY_REWARD',
          description: `Thưởng điểm danh ngày ${streak}`,
        },
      });

      // Ghi log điểm danh
      await tx.checkInLog.create({
        data: {
          userId,
          dayCount: streak,
          coinsEarned: totalCoins,
        },
      });

      return {
        coinsEarned: totalCoins,
        currentStreak: streak,
        totalCoins: updatedUser.coins,
      };
    });
  }
}
      // components/Reader.tsx
'use client';

import { useState } from 'react';
import { motion } from 'framer-motion';
import { Sun, Moon, BookOpen, Settings } from 'lucide-react';

interface Props {
  title: string;
  chapterNum: number;
  content: string;
}

export default function Reader({ title, chapterNum, content }: Props) {
  const [theme, setTheme] = useState<'dark' | 'light' | 'sepia'>('dark');
  const [fontSize, setFontSize] = useState<number>(18);
  const [lineHeight, setLineHeight] = useState<number>(1.8);

  const themeClasses = {
    dark: 'bg-[#0f172a] text-[#e2e8f0]',
    light: 'bg-[#ffffff] text-[#1e293b]',
    sepia: 'bg-[#fbf0d9] text-[#5f4b32]',
  };

  return (
    <div className={`min-h-screen transition-colors duration-300 ${themeClasses[theme]}`}>
      {/* Dynamic Header */}
      <header className="sticky top-0 z-50 backdrop-blur-md bg-opacity-80 border-b border-white/10 px-6 py-4 flex justify-between items-center">
        <h1 className="text-lg font-bold truncate">
          Chương {chapterNum}: {title}
        </h1>

        {/* Toolbar */}
        <div className="flex items-center gap-4">
          <button
            onClick={() => setTheme(theme === 'dark' ? 'light' : theme === 'light' ? 'sepia' : 'dark')}
            className="p-2 rounded-full hover:bg-white/10 transition"
          >
            {theme === 'dark' ? <Moon className="w-5 h-5 text-purple-400" /> : <Sun className="w-5 h-5 text-amber-500" />}
          </button>
          
          <div className="flex items-center gap-2 bg-black/20 p-1.5 rounded-lg">
            <button onClick={() => setFontSize((p) => Math.max(14, p - 2))} className="px-2 text-sm font-bold">-</button>
            <span className="text-xs">{fontSize}px</span>
            <button onClick={() => setFontSize((p) => Math.min(28, p + 2))} className="px-2 text-sm font-bold">+</button>
          </div>
        </div>
      </header>

      {/* Novel Content */}
      <main className="max-w-3xl mx-auto px-4 py-12">
        <motion.div
          initial={{ opacity: 0, y: 10 }}
          animate={{ opacity: 1, y: 0 }}
          transition={{ duration: 0.4 }}
          style={{ fontSize: `${fontSize}px`, lineHeight: lineHeight }}
          className="whitespace-pre-line font-serif selection:bg-purple-500 selection:text-white"
        >
          {content}
        </motion.div>
      </main>
    </div>
  );
}
              // components/CheckInModal.tsx
'use client';

import { useState } from 'react';
import { motion, AnimatePresence } from 'framer-motion';
import { Gift, Zap, CheckCircle2 } from 'lucide-react';

export default function CheckInModal({ currentStreak = 3 }: { currentStreak?: number }) {
  const [isOpen, setIsOpen] = useState(false);
  const [claimed, setClaimed] = useState(false);

  const handleCheckIn = async () => {
    // Gọi API `/api/gamification/check-in`
    setClaimed(true);
  };

  return (
    <>
      <button
        onClick={() => setIsOpen(true)}
        className="flex items-center gap-2 px-4 py-2 rounded-xl bg-gradient-to-r from-purple-600 to-indigo-600 hover:from-purple-500 hover:to-indigo-500 text-white font-medium shadow-lg shadow-purple-500/20 transition-all"
      >
        <Zap className="w-4 h-4 text-yellow-400" />
        <span>Điểm danh</span>
      </button>

      <AnimatePresence>
        {isOpen && (
          <div className="fixed inset-0 z-50 flex items-center justify-center p-4 bg-black/60 backdrop-blur-sm">
            <motion.div
              initial={{ scale: 0.9, opacity: 0 }}
              animate={{ scale: 1, opacity: 1 }}
              exit={{ scale: 0.9, opacity: 0 }}
              className="relative w-full max-w-md p-6 bg-[#18181b]/80 border border-white/10 rounded-2xl backdrop-blur-xl shadow-2xl text-white"
            >
              <div className="text-center">
                <div className="w-16 h-16 mx-auto mb-4 flex items-center justify-center rounded-full bg-purple-500/10 border border-purple-500/30 text-purple-400">
                  <Gift className="w-8 h-8" />
                </div>
                <h3 className="text-xl font-bold">Điểm Danh Hằng Ngày</h3>
                <p className="text-sm text-gray-400 mt-1">
                  Chuỗi hiện tại: <span className="text-yellow-400 font-bold">{currentStreak} ngày</span> 🔥
                </p>
              </div>

              {/* Grid 7 ngày mẫu */}
              <div className="grid grid-cols-4 gap-2 my-6">
                {[1, 2, 3, 4, 5, 6, 7].map((day) => (
                  <div
                    key={day}
                    className={`p-3 rounded-xl border flex flex-col items-center justify-center gap-1 ${
                      day <= currentStreak
                        ? 'bg-purple-600/20 border-purple-500/50 text-purple-300'
                        : 'bg-white/5 border-white/5 text-gray-500'
                    }`}
                  >
                    <span className="text-xs">Ngày {day}</span>
                    <span className="text-sm font-bold text-yellow-400">+{20 + day * 5}</span>
                  </div>
                ))}
              </div>

              <button
                disabled={claimed}
                onClick={handleCheckIn}
                className="w-full py-3 rounded-xl font-semibold bg-gradient-to-r from-yellow-500 to-amber-600 text-black hover:brightness-110 disabled:opacity-50 transition flex items-center justify-center gap-2"
              >
                {claimed ? (
                  <>
                    <CheckCircle2 className="w-5 h-5 text-black" /> Đã nhận thưởng
                  </>
                ) : (
                  'Nhận Xu Hôm Nay'
                )}
              </button>

              <button
                onClick={() => setIsOpen(false)}
                className="absolute top-4 right-4 text-gray-400 hover:text-white"
              >
                ✕
              </button>
            </motion.div>
          </div>
        )}
      </AnimatePresence>
    </>
  );
}