WebRTC

// Node.js 시그널링 서버 (Socket.IO)
const express = require('express');
const http = require('http');
const { Server } = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = new Server(server, {
    cors: { origin: '*' }
});

const rooms = new Map();

io.on('connection', (socket) => {
    console.log('User connected:', socket.id);

    // 방 참가
    socket.on('join-room', (roomId) => {
        socket.join(roomId);

        if (!rooms.has(roomId)) {
            rooms.set(roomId, new Set());
        }
        rooms.get(roomId).add(socket.id);

        // 기존 참가자들에게 알림
        socket.to(roomId).emit('user-joined', socket.id);

        // 기존 참가자 목록 전송
        const existingUsers = [...rooms.get(roomId)].filter(id => id !== socket.id);
        socket.emit('existing-users', existingUsers);
    });

    // Offer 전달
    socket.on('offer', ({ targetId, sdp }) => {
        io.to(targetId).emit('offer', {
            senderId: socket.id,
            sdp
        });
    });

    // Answer 전달
    socket.on('answer', ({ targetId, sdp }) => {
        io.to(targetId).emit('answer', {
            senderId: socket.id,
            sdp
        });
    });

    // ICE Candidate 전달
    socket.on('ice-candidate', ({ targetId, candidate }) => {
        io.to(targetId).emit('ice-candidate', {
            senderId: socket.id,
            candidate
        });
    });

    // 연결 해제
    socket.on('disconnect', () => {
        rooms.forEach((users, roomId) => {
            if (users.has(socket.id)) {
                users.delete(socket.id);
                socket.to(roomId).emit('user-left', socket.id);
            }
        });
    });
});

server.listen(3000, () => {
    console.log('Signaling server running on port 3000');
});

// 화면 공유 구현
async function startScreenShare() {
    try {
        // 화면 캡처 스트림 획득
        const screenStream = await navigator.mediaDevices.getDisplayMedia({
            video: {
                cursor: 'always',  // 마우스 커서 표시
                displaySurface: 'monitor'  // 전체 화면 | 'window' | 'tab'
            },
            audio: true  // 시스템 오디오 (브라우저 지원에 따라)
        });

        // 기존 비디오 트랙을 화면 공유로 교체
        const videoTrack = screenStream.getVideoTracks()[0];
        const sender = peerConnection.getSenders().find(
            s => s.track?.kind === 'video'
        );

        if (sender) {
            await sender.replaceTrack(videoTrack);
        }

        // 화면 공유 중단 감지
        videoTrack.onended = () => {
            console.log('Screen sharing stopped');
            stopScreenShare();
        };

        return screenStream;
    } catch (error) {
        if (error.name === 'NotAllowedError') {
            console.log('User denied screen sharing');
        }
        throw error;
    }
}

// DataChannel로 파일 전송
function setupDataChannel() {
    const dataChannel = peerConnection.createDataChannel('fileTransfer', {
        ordered: true,  // 순서 보장
        maxRetransmits: 3  // 재전송 횟수
    });

    dataChannel.onopen = () => {
        console.log('DataChannel opened');
    };

    dataChannel.onmessage = (event) => {
        // 수신된 데이터 처리
        const data = JSON.parse(event.data);
        if (data.type === 'file-chunk') {
            handleFileChunk(data);
        }
    };

    // 파일을 청크로 나누어 전송
    async function sendFile(file) {
        const chunkSize = 16384;  // 16KB 청크
        const reader = new FileReader();
        let offset = 0;

        // 파일 메타데이터 전송
        dataChannel.send(JSON.stringify({
            type: 'file-start',
            name: file.name,
            size: file.size,
            mimeType: file.type
        }));

        // 청크 단위로 전송
        while (offset < file.size) {
            const chunk = file.slice(offset, offset + chunkSize);
            const buffer = await chunk.arrayBuffer();

            dataChannel.send(JSON.stringify({
                type: 'file-chunk',
                data: Array.from(new Uint8Array(buffer)),
                offset
            }));

            offset += chunkSize;
        }

        dataChannel.send(JSON.stringify({ type: 'file-end' }));
    }

    return { dataChannel, sendFile };
}

// 연결 품질 통계
async function getConnectionStats() {
    const stats = await peerConnection.getStats();

    stats.forEach(report => {
        if (report.type === 'inbound-rtp' && report.kind === 'video') {
            console.log('Video Stats:', {
                framesReceived: report.framesReceived,
                framesDropped: report.framesDropped,
                bytesReceived: report.bytesReceived,
                packetsLost: report.packetsLost
            });
        }
    });
}