알림 시스템: 실시간 + 배치

[Real-time (즉시)]
- 멘션, 답글, DM
- 인앱 + 푸시

[Important (5분 이내)]
- 새 팔로워, 좋아요 (첫 5개만)
- 인앱 + 푸시

[Digest (시간/일별)]
- 댓글 좋아요, 일반 활동
- 이메일 다이제스트

[Off]
- 사용자가 끈 항목

CREATE TABLE notifications (
  id UUID PRIMARY KEY,
  user_id UUID NOT NULL,
  type VARCHAR NOT NULL,
  title VARCHAR NOT NULL,
  body TEXT,
  link VARCHAR,
  data JSONB,
  read_at TIMESTAMP,
  created_at TIMESTAMP DEFAULT NOW()
);

CREATE INDEX ON notifications(user_id, created_at DESC);
CREATE INDEX ON notifications(user_id, created_at DESC) WHERE read_at IS NULL;


CREATE TABLE notification_preferences (
  user_id UUID NOT NULL,
  type VARCHAR NOT NULL,
  channel VARCHAR NOT NULL,  -- 'in_app', 'email', 'push'
  enabled BOOLEAN DEFAULT true,
  PRIMARY KEY (user_id, type, channel)
);


-- 묶기 (예: 좋아요 5개 → "5명이 좋아요")
CREATE TABLE notification_aggregates (
  user_id UUID,
  type VARCHAR,
  target_id UUID,
  count INT DEFAULT 1,
  actors JSONB,  -- [{id, name}, ...]
  last_at TIMESTAMP,
  notified_at TIMESTAMP,
  PRIMARY KEY (user_id, type, target_id)
);

async function notify(input: {
  userId: string;
  type: string;
  title: string;
  body?: string;
  link?: string;
  data?: any;
  actorId?: string;        // 좋아요 누른 사람
  targetId?: string;       // 대상 게시물
  aggregable?: boolean;    // 묶기 가능
}) {
  // 1. 선호도 확인
  const prefs = await db.notificationPreference.findMany({
    where: { userId: input.userId, type: input.type },
  });
  const allowed = prefs.reduce((acc, p) => ({ ...acc, [p.channel]: p.enabled }), {} as any);

  // 2. Rate limit 검증
  const recentCount = await redis.incr(`notif_rate:${input.userId}`);
  if (recentCount === 1) await redis.expire(`notif_rate:${input.userId}`, 60);
  if (recentCount > 30) {
    // 1분에 30개 이상 — 묶기 모드
    await aggregate(input);
    return;
  }

  // 3. Aggregable인 경우 묶기 처리
  if (input.aggregable && input.targetId && input.actorId) {
    return aggregate(input);
  }

  // 4. 채널별 발송
  if (allowed.in_app !== false) {
    const notif = await db.notification.create({ data: input });
    io.to(`user:${input.userId}`).emit('notification', notif);
  }

  if (allowed.email) {
    await emailQueue.add('notification', input);
  }

  if (allowed.push) {
    await pushQueue.add('send', input);
  }
}

async function aggregate(input: any) {
  const key = { userId: input.userId, type: input.type, targetId: input.targetId };

  return db.$transaction(async (tx) => {
    const existing = await tx.notificationAggregate.findUnique({ where: { ...key as any } });

    const actor = { id: input.actorId, name: input.data?.actorName };
    const actors = existing
      ? [actor, ...(existing.actors as any[]).filter(a => a.id !== input.actorId).slice(0, 4)]
      : [actor];

    const updated = await tx.notificationAggregate.upsert({
      where: { ...key as any },
      create: {
        ...key, count: 1, actors, lastAt: new Date(),
      },
      update: {
        count: { increment: 1 },
        actors,
        lastAt: new Date(),
      },
    });

    // 5분 이내 다시 알림 안 보냄
    if (updated.notifiedAt && Date.now() - updated.notifiedAt.getTime() < 5 * 60 * 1000) {
      return;
    }

    // 묶은 알림 생성
    const titleMap: any = {
      like: updated.count === 1
        ? `${actors[0].name}님이 좋아요`
        : `${actors[0].name}님 외 ${updated.count - 1}명이 좋아요`,
      // ...
    };

    const notif = await tx.notification.create({
      data: {
        userId: input.userId,
        type: input.type,
        title: titleMap[input.type],
        link: input.link,
        data: { actors, count: updated.count },
      },
    });

    await tx.notificationAggregate.update({
      where: { ...key as any },
      data: { notifiedAt: new Date() },
    });

    io.to(`user:${input.userId}`).emit('notification', notif);
  });
}

// 매일 아침 9시 — 미읽은 알림 모아서 1통
const digestScheduler = scheduler.upsertJobScheduler(
  'daily-digest',
  { pattern: '0 9 * * *' },
  { name: 'digest' }
);


const digestWorker = new Worker('digest', async () => {
  const usersWithDigest = await db.notificationPreference.findMany({
    where: { type: 'digest', channel: 'email', enabled: true },
    select: { userId: true },
    distinct: ['userId'],
  });

  for (const { userId } of usersWithDigest) {
    const unread = await db.notification.findMany({
      where: {
        userId,
        readAt: null,
        createdAt: { gt: new Date(Date.now() - 86400 * 1000) },
      },
      orderBy: { createdAt: 'desc' },
      take: 20,
    });

    if (unread.length === 0) continue;

    const user = await db.user.findUnique({ where: { id: userId } });
    await emailQueue.add('digest', {
      to: user!.email,
      notifications: unread,
      total: unread.length,
    });
  }
});

function NotificationDropdown({ userId }: { userId: string }) {
  const { data, refetch } = useQuery({
    queryKey: ['notifications'],
    queryFn: () => fetch('/api/notifications?limit=20').then(r => r.json()),
  });

  useEffect(() => {
    socket.on('notification', () => refetch());
    return () => { socket.off('notification'); };
  }, []);

  const markAllRead = async () => {
    await fetch('/api/notifications/read-all', { method: 'POST' });
    refetch();
  };

  return (
    <Dropdown>
      <DropdownHeader>
        <span>알림</span>
        <button onClick={markAllRead}>모두 읽음</button>
      </DropdownHeader>
      {data?.items.map(n => (
        <NotificationItem
          key={n.id}
          notification={n}
          onClick={() => markRead(n.id)}
        />
      ))}
    </Dropdown>
  );
}