// 카메라와 마이크 접근 요청
navigator.mediaDevices.getUserMedia({
  video: true,
  audio: true
})
.then(function(stream) {
  // 성공! stream을 video 요소에 연결
  const videoElement = document.querySelector('video');
  videoElement.srcObject = stream;
})
.catch(function(error) {
  console.error('미디어 접근 실패:', error);
});

// Peer A: Offer 생성
const offer = await peerConnection.createOffer();
await peerConnection.setLocalDescription(offer);
// 이 offer를 시그널링 서버를 통해 Peer B에게 전송

// Peer B: Offer 받고 Answer 생성
await peerConnection.setRemoteDescription(receivedOffer);
const answer = await peerConnection.createAnswer();
await peerConnection.setLocalDescription(answer);
// 이 answer를 Peer A에게 전송

// ICE candidate 이벤트 리스너
peerConnection.onicecandidate = (event) => {
  if (event.candidate) {
    // 이 candidate를 시그널링 서버를 통해 상대방에게 전송
    sendToSignalingServer({
      type: 'ice-candidate',
      candidate: event.candidate
    });
  }
};

const configuration = {
  iceServers: [
    { urls: 'stun:stun.l.google.com:19302' },
    { urls: 'stun:stun1.l.google.com:19302' },
    { urls: 'stun:stun2.l.google.com:19302' }
  ]
};

const configuration = {
  iceServers: [
    { urls: 'stun:stun.l.google.com:19302' },
    {
      urls: 'turn:your-turn-server.com:3478',
      username: 'username',
      credential: 'password'
    }
  ]
};

// 비트레이트 제한 설정
const sender = peerConnection.getSenders().find(s => s.track.kind === 'video');
const parameters = sender.getParameters();

if (!parameters.encodings) {
  parameters.encodings = [{}];
}

// 최대 비트레이트 설정 (bps)
parameters.encodings[0].maxBitrate = 1000000; // 1 Mbps

await sender.setParameters(parameters);

// 네트워크 상태 모니터링
peerConnection.getStats().then(stats => {
  stats.forEach(report => {
    if (report.type === 'inbound-rtp' && report.kind === 'video') {
      console.log('수신 비트레이트:', report.bytesReceived);
      console.log('패킷 손실:', report.packetsLost);
      console.log('지터:', report.jitter);
    }
  });
});

// Let's Encrypt로 무료 SSL 인증서 발급
// Certbot 사용 예시
sudo certbot --nginx -d yourdomain.com

// Node.js에서 HTTPS 서버 설정
const https = require('https');
const fs = require('fs');

const options = {
  key: fs.readFileSync('/path/to/private.key'),
  cert: fs.readFileSync('/path/to/certificate.crt')
};

const server = https.createServer(options, app);
server.listen(443);

// JWT 토큰을 사용한 인증
const jwt = require('jsonwebtoken');

// 토큰 생성
const token = jwt.sign(
  { userId: user.id, roomId: room.id },
  process.env.JWT_SECRET,
  { expiresIn: '1h' }
);

// 토큰 검증
io.use((socket, next) => {
  const token = socket.handshake.auth.token;
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    socket.userId = decoded.userId;
    next();
  } catch (err) {
    next(new Error('Authentication error'));
  }
});

// 화면 공유 시작
async function startScreenShare() {
  try {
    const screenStream = await navigator.mediaDevices.getDisplayMedia({
      video: {
        cursor: 'always',  // 커서 표시
        displaySurface: 'monitor'  // 'monitor', 'window', 'application'
      },
      audio: true  // 시스템 오디오 포함 (브라우저 지원 필요)
    });
    
    // 비디오 트랙 교체
    const videoTrack = screenStream.getVideoTracks()[0];
    const sender = peerConnection.getSenders().find(s => s.track.kind === 'video');
    sender.replaceTrack(videoTrack);
    
    // 화면 공유 중단 감지
    videoTrack.onended = () => {
      console.log('화면 공유가 중단되었습니다');
      // 원래 카메라로 복귀
      const cameraTrack = localStream.getVideoTracks()[0];
      sender.replaceTrack(cameraTrack);
    };
    
  } catch (error) {
    console.error('화면 공유 오류:', error);
  }
}

// 오디오 음소거/해제
function toggleAudio() {
  const audioTrack = localStream.getAudioTracks()[0];
  audioTrack.enabled = !audioTrack.enabled;
  return audioTrack.enabled;
}

// 비디오 끄기/켜기
function toggleVideo() {
  const videoTrack = localStream.getVideoTracks()[0];
  videoTrack.enabled = !videoTrack.enabled;
  return videoTrack.enabled;
}

// 버튼 이벤트
document.getElementById('muteButton').onclick = () => {
  const isEnabled = toggleAudio();
  // UI 업데이트
  document.getElementById('muteButton').textContent = 
    isEnabled ? '🎤 음소거' : '🔇 음소거 해제';
};

document.getElementById('videoButton').onclick = () => {
  const isEnabled = toggleVideo();
  document.getElementById('videoButton').textContent = 
    isEnabled ? '📹 비디오 끄기' : '📵 비디오 켜기';
};

// Data Channel 생성
const dataChannel = peerConnection.createDataChannel('chat');

dataChannel.onopen = () => {
  console.log('데이터 채널 연결됨');
};

dataChannel.onmessage = (event) => {
  const message = JSON.parse(event.data);
  displayMessage(message);
};

// 메시지 전송
function sendMessage(text) {
  const message = {
    sender: myName,
    text: text,
    timestamp: Date.now()
  };
  dataChannel.send(JSON.stringify(message));
  displayMessage(message);
}

// 수신자 측에서 Data Channel 받기
peerConnection.ondatachannel = (event) => {
  const receiveChannel = event.channel;
  receiveChannel.onmessage = (e) => {
    const message = JSON.parse(e.data);
    displayMessage(message);
  };
};

// TensorFlow.js와 BodyPix 로드
import * as bodyPix from '@tensorflow-models/body-pix';

async function applyVirtualBackground() {
  // 모델 로드
  const net = await bodyPix.load();
  
  // 캔버스 설정
  const canvas = document.createElement('canvas');
  const ctx = canvas.getContext('2d');
  const video = document.getElementById('localVideo');
  
  canvas.width = video.videoWidth;
  canvas.height = video.videoHeight;
  
  // 배경 이미지 로드
  const backgroundImage = new Image();
  backgroundImage.src = 'background.jpg';
  
  async function processFrame() {
    // 사람 세그멘테이션
    const segmentation = await net.segmentPerson(video);
    
    // 배경 그리기
    ctx.drawImage(backgroundImage, 0, 0, canvas.width, canvas.height);
    
    // 사람 부분만 원본 비디오에서 가져오기
    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
    const pixel = imageData.data;
    
    for (let i = 0; i < segmentation.data.length; i++) {
      if (segmentation.data[i] === 1) {
        // 사람 영역은 원본 비디오 픽셀 사용
        const videoPixel = getVideoPixel(video, i);
        pixel[i * 4] = videoPixel.r;
        pixel[i * 4 + 1] = videoPixel.g;
        pixel[i * 4 + 2] = videoPixel.b;
      }
    }
    
    ctx.putImageData(imageData, 0, 0);
    requestAnimationFrame(processFrame);
  }
  
  processFrame();
  
  // 캔버스 스트림을 PeerConnection에 추가
  const stream = canvas.captureStream(30);
  const videoTrack = stream.getVideoTracks()[0];
  const sender = peerConnection.getSenders().find(s => s.track.kind === 'video');
  sender.replaceTrack(videoTrack);
}

// 네트워크 통계 수집
setInterval(async () => {
  const stats = await peerConnection.getStats();
  let quality = 'good';
  
  stats.forEach(report => {
    if (report.type === 'inbound-rtp' && report.kind === 'video') {
      const packetsLost = report.packetsLost || 0;
      const packetsReceived = report.packetsReceived || 0;
      const lossRate = packetsLost / (packetsLost + packetsReceived);
      
      if (lossRate > 0.1) quality = 'poor';
      else if (lossRate > 0.05) quality = 'fair';
      
      // UI 업데이트
      updateQualityIndicator(quality);
    }
  });
}, 2000);

// npm install simple-peer
const SimplePeer = require('simple-peer');

// Peer A (발신자)
const peer1 = new SimplePeer({ initiator: true, stream: localStream });

peer1.on('signal', data => {
  // 이 data를 Peer B에게 전송 (시그널링 서버 통해)
  socket.emit('signal', data);
});

peer1.on('stream', remoteStream => {
  // 원격 스트림 수신
  remoteVideo.srcObject = remoteStream;
});

// Peer B (수신자)
const peer2 = new SimplePeer({ stream: localStream });

socket.on('signal', data => {
  peer2.signal(data);
});

peer2.on('signal', data => {
  socket.emit('signal', data);
});

peer2.on('stream', remoteStream => {
  remoteVideo.srcObject = remoteStream;
});

const mediasoup = require('mediasoup');

// Worker 생성
const worker = await mediasoup.createWorker({
  logLevel: 'warn',
  rtcMinPort: 10000,
  rtcMaxPort: 10100
});

// Router 생성
const router = await worker.createRouter({
  mediaCodecs: [
    {
      kind: 'audio',
      mimeType: 'audio/opus',
      clockRate: 48000,
      channels: 2
    },
    {
      kind: 'video',
      mimeType: 'video/VP8',
      clockRate: 90000
    }
  ]
});

// WebRTC Transport 생성
const transport = await router.createWebRtcTransport({
  listenIps: [{ ip: '0.0.0.0', announcedIp: 'YOUR_PUBLIC_IP' }],
  enableUdp: true,
  enableTcp: true,
  preferUdp: true
});

// Producer 생성 (송신)
const producer = await transport.produce({
  kind: 'video',
  rtpParameters: clientRtpParameters
});

// Consumer 생성 (수신)
const consumer = await transport.consume({
  producerId: producer.id,
  rtpCapabilities: clientRtpCapabilities
});