WebRTC: 웹의 실시간 통신 혁명

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"log"
	"os"
	"strings"
	"time"

	"github.com/pion/webrtc/v3"
	"github.com/gorilla/websocket" // 시그널링을 위해 사용 (예시)
)

func main() {
	config := webrtc.Configuration{
		ICEServers: []webrtc.ICEServer{
			{
				URLs: []string{"stun:stun.l.google.com:19302"},
			},
		},
	}

	peerConnection, err := webrtc.NewPeerConnection(config)
	if err != nil {
		panic(err)
	}
	defer func() {
		if err := peerConnection.Close(); err != nil {
			fmt.Printf("cannot close peerConnection: %v\n", err)
		}
	}()

	dataChannel, err := peerConnection.CreateDataChannel("data", nil)
	if err != nil {
		panic(err)
	}

	peerConnection.OnICEConnectionStateChange(func(connectionState webrtc.ICEConnectionState) {
		fmt.Printf("ICE Connection State has changed: %s\n", connectionState.String())
	})
    
	dataChannel.OnOpen(func() {
		fmt.Printf("Data channel '%s'-'%d' open. Random messages will now be sent to any connected DataChannels every 5 seconds\n", dataChannel.Label(), dataChannel.ID())
		for range time.NewTicker(5 * time.Second).C {
			message := "Hello from Pion Go Client!"
			fmt.Printf("Sending message: %s\n", message)
			sendErr := dataChannel.SendText(message)
			if sendErr != nil {
				panic(sendErr)
			}
		}
	})

	dataChannel.OnMessage(func(msg webrtc.DataChannelMessage) {
		fmt.Printf("Message from DataChannel '%s': '%s'\n", dataChannel.Label(), string(msg.Data))
	})

	// --- 시그널링 로직 (Offer/Answer, ICE Candidate 교환) 시작 ---
	// 이 부분은 실제 시그널링 서버와 연동하여 구현해야 합니다.
	// 예시: WebSocket을 사용한 메시지 교환
	wsConn, _, wsErr := websocket.DefaultDialer.Dial("ws://localhost:8000/ws", nil)
	if wsErr != nil {
		log.Fatalf("WebSocket dial error: %v", wsErr)
	}
	defer wsConn.Close()
	log.Println("Connected to signaling server")

	peerConnection.OnICECandidate(func(c *webrtc.ICECandidate) {
		if c == nil { return }
		candidateJSON, _ := json.Marshal(c.ToJSON())
		message := map[string]interface{}{"type": "candidate", "payload": c.ToJSON()}
		msgBytes, _ := json.Marshal(message)
		wsConn.WriteMessage(websocket.TextMessage, msgBytes)
		fmt.Println("Sent ICE Candidate: ", string(candidateJSON))
	})

	// Offer 생성 및 전송 (만약 연결을 시작하는 측이라면)
	// offer, err := peerConnection.CreateOffer(nil)
	// if err != nil { panic(err) }
	// peerConnection.SetLocalDescription(offer)
    // offerJSON, _ := json.Marshal(offer)
    // message := map[string]interface{}{"type": "offer", "payload": offer}
    // msgBytes, _ := json.Marshal(message)
    // fmt.Println("Sent Offer")

	go func() {
		for {
			_, message, err := wsConn.ReadMessage()
			if err != nil {
				log.Println("WebSocket read error:", err)
				return
			}
			var sigMsg map[string]interface{}
			json.Unmarshal(message, &sigMsg)

			switch sigMsg["type"] {
			case "offer":
				offer := webrtc.SessionDescription{}
				payloadBytes, _ := json.Marshal(sigMsg["payload"])
				json.Unmarshal(payloadBytes, &offer)
				peerConnection.SetRemoteDescription(offer)
				answer, err := peerConnection.CreateAnswer(nil)
				if err != nil { panic(err) }
				peerConnection.SetLocalDescription(answer)
                answerMsg := map[string]interface{}{"type": "answer", "payload": answer}
                answerBytes, _ := json.Marshal(answerMsg)
				wsConn.WriteMessage(websocket.TextMessage, answerBytes)
				fmt.Println("Received Offer, Sent Answer")
			case "answer":
				answer := webrtc.SessionDescription{}
                payloadBytes, _ := json.Marshal(sigMsg["payload"])
				json.Unmarshal(payloadBytes, &answer)
				peerConnection.SetRemoteDescription(answer)
				fmt.Println("Received Answer")
			case "candidate":
				candidate := webrtc.ICECandidateInit{}
                payloadBytes, _ := json.Marshal(sigMsg["payload"])
				json.Unmarshal(payloadBytes, &candidate)
				peerConnection.AddICECandidate(candidate)
				fmt.Println("Received ICE Candidate")
			}
		}
	}()
	// --- 시그널링 로직 끝 ---

	fmt.Println("Pion WebRTC client started. Press Ctrl+C to exit.")
	select {} // 프로그램이 종료되지 않도록 대기
}