<!-- Maven 의존성 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

<!-- Gradle 의존성 -->
implementation 'org.springframework.boot:spring-boot-starter-websocket'

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
    
    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        // 메시지 브로커 활성화 - 클라이언트로 메시지 전달
        config.enableSimpleBroker("/topic", "/queue");
        
        // 클라이언트에서 서버로 메시지 보낼 때 prefix
        config.setApplicationDestinationPrefixes("/app");
    }
    
    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        // WebSocket 연결 엔드포인트
        registry.addEndpoint("/ws")
                .setAllowedOriginPatterns("*")
                .withSockJS(); // SockJS 폴백 옵션
    }
}

<!-- 필요한 라이브러리 CDN -->
<script src="https://cdn.jsdelivr.net/npm/sockjs-client@1/dist/sockjs.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/stompjs@2.3.3/lib/stomp.min.js"></script>

// WebSocket 연결 및 구독
let stompClient = null;

function connect() {
    const socket = new SockJS('/ws');
    stompClient = Stomp.over(socket);
    
    stompClient.connect({}, function(frame) {
        console.log('Connected: ' + frame);
        
        // 공개 채널 구독
        stompClient.subscribe('/topic/public', function(message) {
            showMessage(JSON.parse(message.body));
        });
        
        // 개인 알림 구독
        stompClient.subscribe('/user/queue/notifications', function(notification) {
            showNotification(JSON.parse(notification.body));
        });
        
        // 입장 메시지 전송
        sendJoinMessage();
    });
}

// 메시지 전송
function sendMessage() {
    const messageContent = document.getElementById('message').value;
    
    if(messageContent && stompClient) {
        const chatMessage = {
            sender: username,
            content: messageContent,
            type: 'CHAT',
            timestamp: new Date()
        };
        
        stompClient.send("/app/chat.sendMessage", 
                        {}, 
                        JSON.stringify(chatMessage));
        
        document.getElementById('message').value = '';
    }
}

// 연결 해제
function disconnect() {
    if(stompClient !== null) {
        const leaveMessage = {
            sender: username,
            type: 'LEAVE'
        };
        
        stompClient.send("/app/chat.addUser", 
                        {}, 
                        JSON.stringify(leaveMessage));
        
        stompClient.disconnect();
    }
    console.log("Disconnected");
}

@Configuration
public class WebSocketSecurityConfig extends AbstractSecurityWebSocketMessageBrokerConfigurer {
    
    @Override
    protected void configureInbound(MessageSecurityMetadataSourceRegistry messages) {
        messages
            // 연결 엔드포인트는 인증 필요
            .simpDestMatchers("/app/**").authenticated()
            // 구독은 인증된 사용자만
            .simpSubscribeDestMatchers("/user/queue/**").authenticated()
            .simpSubscribeDestMatchers("/topic/**").authenticated()
            // 기타 모든 메시지는 거부
            .anyMessage().denyAll();
    }
    
    @Override
    protected boolean sameOriginDisabled() {
        // CSRF 보호 비활성화 (개발 환경에서만)
        return true;
    }
}

// 메시지 압축 설정
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
    config.enableSimpleBroker("/topic", "/queue")
          .setTaskScheduler(taskScheduler())
          .setHeartbeatValue(new long[] {10000, 10000}); // 하트비트 설정
    
    config.setApplicationDestinationPrefixes("/app");
    config.setCacheLimit(4096); // 캐시 크기 설정
}

@Configuration
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
    
    @Override
    public void configureWebSocketTransport(WebSocketTransportRegistration registration) {
        registration
            .setMessageSizeLimit(128 * 1024)      // 메시지 크기 제한: 128KB
            .setSendBufferSizeLimit(512 * 1024)   // 전송 버퍼: 512KB
            .setSendTimeLimit(20 * 1000)          // 전송 타임아웃: 20초
            .setTimeToFirstMessage(30 * 1000);    // 첫 메시지 타임아웃: 30초
    }
}

// RabbitMQ 메시지 브로커 설정
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
    config.enableStompBrokerRelay("/topic", "/queue")
          .setRelayHost("localhost")
          .setRelayPort(61613)
          .setClientLogin("guest")
          .setClientPasscode("guest")
          .setSystemLogin("guest")
          .setSystemPasscode("guest");
    
    config.setApplicationDestinationPrefixes("/app");
}

// 로깅 설정 (application.yml)
logging:
  level:
    org.springframework.messaging: DEBUG
    org.springframework.web.socket: DEBUG
    org.springframework.messaging.simp: TRACE

// WebSocket 이벤트 리스너
@Component
public class WebSocketEventListener {
    
    private static final Logger logger = LoggerFactory.getLogger(WebSocketEventListener.class);
    
    @Autowired
    private SimpMessageSendingOperations messagingTemplate;
    
    @EventListener
    public void handleWebSocketConnectListener(SessionConnectedEvent event) {
        logger.info("새로운 WebSocket 연결 수립");
    }
    
    @EventListener
    public void handleWebSocketDisconnectListener(SessionDisconnectEvent event) {
        StompHeaderAccessor headerAccessor = StompHeaderAccessor.wrap(event.getMessage());
        
        String username = (String) headerAccessor.getSessionAttributes().get("username");
        if(username != null) {
            logger.info("사용자 연결 해제: " + username);
            
            ChatMessage chatMessage = new ChatMessage();
            chatMessage.setType(MessageType.LEAVE);
            chatMessage.setSender(username);
            
            messagingTemplate.convertAndSend("/topic/public", chatMessage);
        }
    }
    
    @EventListener
    public void handleSessionSubscribeEvent(SessionSubscribeEvent event) {
        StompHeaderAccessor headerAccessor = StompHeaderAccessor.wrap(event.getMessage());
        logger.info("새로운 구독: " + headerAccessor.getDestination());
    }
}

// 채팅방 서비스
@Service
public class ChatRoomService {
    
    private final Map<String, ChatRoom> chatRooms = new ConcurrentHashMap<>();
    
    @PostConstruct
    private void init() {
        // 기본 채팅방 생성
        ChatRoom defaultRoom = ChatRoom.create("일반 채팅방");
        chatRooms.put(defaultRoom.getRoomId(), defaultRoom);
    }
    
    public List<ChatRoom> findAllRooms() {
        return new ArrayList<>(chatRooms.values());
    }
    
    public ChatRoom findRoomById(String roomId) {
        return chatRooms.get(roomId);
    }
    
    public ChatRoom createRoom(String name) {
        ChatRoom chatRoom = ChatRoom.create(name);
        chatRooms.put(chatRoom.getRoomId(), chatRoom);
        return chatRoom;
    }
}

// 채팅방 엔티티
@Getter
@Setter
public class ChatRoom {
    private String roomId;
    private String name;
    private Set<String> users = new HashSet<>();
    private LocalDateTime createdAt;
    
    public static ChatRoom create(String name) {
        ChatRoom room = new ChatRoom();
        room.roomId = UUID.randomUUID().toString();
        room.name = name;
        room.createdAt = LocalDateTime.now();
        return room;
    }
    
    public void addUser(String username) {
        users.add(username);
    }
    
    public void removeUser(String username) {
        users.remove(username);
    }
    
    public int getUserCount() {
        return users.size();
    }
}

// 채팅방 컨트롤러
@Controller
@RequiredArgsConstructor
public class ChatRoomController {
    
    private final ChatRoomService chatRoomService;
    private final SimpMessagingTemplate messagingTemplate;
    
    // 채팅방 입장
    @MessageMapping("/chat.enter/{roomId}")
    public void enterRoom(@DestinationVariable String roomId,
                         @Payload ChatMessage message,
                         SimpMessageHeaderAccessor headerAccessor) {
        
        ChatRoom room = chatRoomService.findRoomById(roomId);
        if (room != null) {
            room.addUser(message.getSender());
            
            // 세션에 사용자 정보 저장
            headerAccessor.getSessionAttributes().put("username", message.getSender());
            headerAccessor.getSessionAttributes().put("roomId", roomId);
            
            // 입장 메시지 브로드캐스트
            message.setType(MessageType.JOIN);
            message.setContent(message.getSender() + "님이 입장하셨습니다.");
            messagingTemplate.convertAndSend("/topic/room/" + roomId, message);
            
            // 현재 인원 수 업데이트
            updateRoomUserCount(roomId, room.getUserCount());
        }
    }
    
    // 채팅 메시지 전송
    @MessageMapping("/chat.message/{roomId}")
    public void sendMessage(@DestinationVariable String roomId,
                           @Payload ChatMessage message) {
        
        message.setTimestamp(LocalDateTime.now());
        messagingTemplate.convertAndSend("/topic/room/" + roomId, message);
    }
    
    // 채팅방 나가기
    @MessageMapping("/chat.leave/{roomId}")
    public void leaveRoom(@DestinationVariable String roomId,
                         @Payload ChatMessage message) {
        
        ChatRoom room = chatRoomService.findRoomById(roomId);
        if (room != null) {
            room.removeUser(message.getSender());
            
            message.setType(MessageType.LEAVE);
            message.setContent(message.getSender() + "님이 퇴장하셨습니다.");
            messagingTemplate.convertAndSend("/topic/room/" + roomId, message);
            
            updateRoomUserCount(roomId, room.getUserCount());
        }
    }
    
    private void updateRoomUserCount(String roomId, int count) {
        Map<String, Object> payload = new HashMap<>();
        payload.put("roomId", roomId);
        payload.put("userCount", count);
        messagingTemplate.convertAndSend("/topic/room/" + roomId + "/count", payload);
    }
}

// Gatling 시뮬레이션 예제
class WebSocketSimulation extends Simulation {
    
    val httpProtocol = http
        .baseUrl("http://localhost:8080")
        .wsBaseUrl("ws://localhost:8080")
    
    val scn = scenario("WebSocket Load Test")
        .exec(ws("Connect")
            .connect("/ws"))
        .pause(1)
        .exec(ws("Subscribe")
            .sendText("""{"type":"SUBSCRIBE","destination":"/topic/public"}"""))
        .pause(1)
        .repeat(100) {
            exec(ws("Send Message")
                .sendText("""{"type":"CHAT","content":"Test message","sender":"user"}"""))
            .pause(1)
        }
        .exec(ws("Close").close)
    
    setUp(
        scn.inject(
            rampUsers(1000) during (60 seconds)
        )
    ).protocols(httpProtocol)
}

// application-prod.yml (프로덕션 설정)
spring:
  websocket:
    message-size-limit: 128KB
    send-buffer-size-limit: 512KB
    send-time-limit: 20000
    
server:
  tomcat:
    max-connections: 10000
    threads:
      max: 200
      min-spare: 10
      
management:
  endpoints:
    web:
      exposure:
        include: health,metrics,websocket
  metrics:
    export:
      prometheus:
        enabled: true

// Nginx 설정 예제
upstream websocket {
    server localhost:8080;
}

server {
    listen 80;
    
    location /ws {
        proxy_pass http://websocket;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_connect_timeout 7d;
        proxy_send_timeout 7d;
        proxy_read_timeout 7d;
    }
}