package com.icoderoad.danmaku.model;


import lombok.Data;


/**
 * 表示一條彈幕消息的實體類
 */
@Data
public class DanmakuMessage {
    private String userId;       // 用戶唯一標識
    private String content;      // 彈幕內容
    private long timestamp;      // 消息發送的時間戳（ms）
    private String color;        // 彈幕顏色（可選）
    private String type;         // 彈幕類型，如 scroll、top、bottom
}

package com.icoderoad.danmaku.service;


import com.icoderoad.danmaku.model.DanmakuMessage;
import org.springframework.stereotype.Service;


import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;


/**
 * 管理實時彈幕緩沖隊列的服務
 */
@Service
public class DanmakuBufferService {


    // 彈幕接收緩沖區，線程安全
    private final Queue<DanmakuMessage> writeQueue = new ConcurrentLinkedQueue<>();


    /**
     * 添加彈幕消息
     */
    public void addMessage(DanmakuMessage message) {
        writeQueue.offer(message);
    }


    /**
     * 批量獲取彈幕（用于調度器分發）
     */
    public Queue<DanmakuMessage> fetchAll() {
        Queue<DanmakuMessage> result = new ConcurrentLinkedQueue<>();
        DanmakuMessage msg;
        while ((msg = writeQueue.poll()) != null) {
            result.offer(msg);
        }
        return result;
    }
}

package com.icoderoad.danmaku.websocket;


import com.icoderoad.danmaku.model.DanmakuMessage;
import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.websocket.*;
import jakarta.websocket.server.ServerEndpoint;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;


import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;


/**
 * WebSocket 處理類，實現實時通信
 */
@Slf4j
@Component
@ServerEndpoint(value = "/ws/danmaku")
public class DanmakuWebSocketServer {


    private static final Set<Session> clients = new CopyOnWriteArraySet<>();
    private static final ObjectMapper mapper = new ObjectMapper();


    @OnOpen
    public void onOpen(Session session) {
        clients.add(session);
        log.info("新連接加入: {}", session.getId());
    }


    @OnMessage
    public void onMessage(String message, Session session) {
        try {
            DanmakuMessage danmaku = mapper.readValue(message, DanmakuMessage.class);
            for (Session client : clients) {
                client.getAsyncRemote().sendText(mapper.writeValueAsString(danmaku));
            }
        } catch (Exception e) {
            log.error("消息處理失敗", e);
        }
    }


    @OnClose
    public void onClose(Session session) {
        clients.remove(session);
        log.info("連接關閉: {}", session.getId());
    }


    @OnError
    public void onError(Session session, Throwable throwable) {
        log.error("連接異常: {}", session.getId(), throwable);
    }


    /**
     * 主動推送（用于后臺調度）
     */
    public static void broadcast(DanmakuMessage message) throws Exception {
        String msg = mapper.writeValueAsString(message);
        for (Session client : clients) {
            client.getAsyncRemote().sendText(msg);
        }
    }
}

package com.icoderoad.danmaku.security;


import jakarta.annotation.Resource;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;


/**
 * 限流服務（基于 Redis）
 */
@Service
public class RateLimiterService {


    @Resource
    private StringRedisTemplate redisTemplate;


    /**
     * 判斷是否允許發送彈幕
     * 限制頻率為：每用戶 1 秒 1 條
     */
    public boolean canSend(String userId) {
        String key = "danmaku:limit:" + userId;
        Boolean exist = redisTemplate.hasKey(key);
        if (Boolean.TRUE.equals(exist)) {
            return false; // 剛剛發過，限流
        }
        redisTemplate.opsForValue().set(key, "1", java.time.Duration.ofSeconds(1));
        return true;
    }
}

public boolean containsIllegalContent(String content) {
    String[] illegalWords = {"垃圾", "罵人詞"};
    for (String word : illegalWords) {
        if (content.contains(word)) return true;
    }
    return false;
}

const canvas = document.getElementById('danmakuCanvas');
const ctx = canvas.getContext('2d');


let messages = [];


function Danmaku(text, color, speed, y) {
    this.text = text;
    this.color = color;
    this.speed = speed;
    this.x = canvas.width;
    this.y = y;
}


Danmaku.prototype.draw = function () {
    ctx.font = "20px Arial";
    ctx.fillStyle = this.color || "#ffffff";
    ctx.fillText(this.text, this.x, this.y);
    this.x -= this.speed;
}


function render() {
    ctx.clearRect(0, 0, canvas.width, canvas.height);
    messages.forEach(msg => msg.draw());
    messages = messages.filter(m => m.x + ctx.measureText(m.text).width > 0);
    requestAnimationFrame(render);
}


render();