package ai.giskard.learnspringwebsockets;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.socket.*;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
import org.springframework.web.socket.server.RequestUpgradeStrategy;
import org.springframework.web.socket.server.support.AbstractHandshakeHandler;

import java.io.IOException;
import java.security.Principal;
import java.util.List;
import java.util.Map;

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(myHandler(), "/websocket").setHandshakeHandler(new AbstractHandshakeHandler() {
            @Override
            public RequestUpgradeStrategy getRequestUpgradeStrategy() {
                System.out.println("public RequestUpgradeStrategy getRequestUpgradeStrategy() {");
                return super.getRequestUpgradeStrategy();
            }

            @Override
            public void setSupportedProtocols(String... protocols) {
                System.out.println("public void setSupportedProtocols(String... protocols) {");
                super.setSupportedProtocols(protocols);
            }

            @Override
            public String[] getSupportedProtocols() {
                System.out.println("public String[] getSupportedProtocols() {");
                return super.getSupportedProtocols();
            }

            @Override
            public void start() {
                System.out.println("public void start() {");
                super.start();
            }

            @Override
            protected void doStart() {
                System.out.println("protected void doStart() {");
                super.doStart();
            }

            @Override
            public void stop() {
                System.out.println("public void stop() {");
                super.stop();
            }

            @Override
            protected void doStop() {
                System.out.println("protected void doStop() {");
                super.doStop();
            }

            @Override
            public boolean isRunning() {
                System.out.println("public boolean isRunning() {");
                return super.isRunning();
            }

            @Override
            protected void handleInvalidUpgradeHeader(ServerHttpRequest request, ServerHttpResponse response) throws IOException {
                System.out.println("protected void handleInvalidUpgradeHeader(ServerHttpRequest request, ServerHttpResponse response) throws IOException {");
                super.handleInvalidUpgradeHeader(request, response);
            }

            @Override
            protected void handleInvalidConnectHeader(ServerHttpRequest request, ServerHttpResponse response) throws IOException {
                System.out.println("protected void handleInvalidConnectHeader(ServerHttpRequest request, ServerHttpResponse response) throws IOException {");
                super.handleInvalidConnectHeader(request, response);
            }

            @Override
            protected boolean isWebSocketVersionSupported(WebSocketHttpHeaders httpHeaders) {
                httpHeaders.toSingleValueMap().forEach((k, v) -> System.out.println(k + " -> " + v));
                System.out.println("protected boolean isWebSocketVersionSupported(WebSocketHttpHeaders httpHeaders) {");
                return super.isWebSocketVersionSupported(httpHeaders);
            }

            @Override
            protected String[] getSupportedVersions() {
                System.out.println("protected String[] getSupportedVersions() {");
                return super.getSupportedVersions();
            }

            @Override
            protected void handleWebSocketVersionNotSupported(ServerHttpRequest request, ServerHttpResponse response) {
                System.out.println("protected void handleWebSocketVersionNotSupported(ServerHttpRequest request, ServerHttpResponse response) {");
                super.handleWebSocketVersionNotSupported(request, response);
            }

            @Override
            protected boolean isValidOrigin(ServerHttpRequest request) {
                System.out.println("protected boolean isValidOrigin(ServerHttpRequest request) {");
                return super.isValidOrigin(request);
            }

            @Override
            protected String selectProtocol(List<String> requestedProtocols, WebSocketHandler webSocketHandler) {
                System.out.println("protected String selectProtocol(List<String> requestedProtocols, WebSocketHandler webSocketHandler) {");
                return super.selectProtocol(requestedProtocols, webSocketHandler);
            }

            @Override
            protected List<WebSocketExtension> filterRequestedExtensions(ServerHttpRequest request, List<WebSocketExtension> requestedExtensions, List<WebSocketExtension> supportedExtensions) {
                System.out.println("protected List<WebSocketExtension> filterRequestedExtensions(ServerHttpRequest request, List<WebSocketExtension> requestedExtensions, List<WebSocketExtension> supportedExtensions) {");
                return super.filterRequestedExtensions(request, requestedExtensions, supportedExtensions);
            }

            @Override
            protected Principal determineUser(ServerHttpRequest request, WebSocketHandler wsHandler, Map<String, Object> attributes) {
                System.out.println("protected Principal determineUser(ServerHttpRequest request, WebSocketHandler wsHandler, Map<String, Object> attributes) {");
                return super.determineUser(request, wsHandler, attributes);
            }
        });
    }

    public WebSocketHandler myHandler() {
        return new WebSocketHandler() {

            @Override
            public void afterConnectionEstablished(WebSocketSession session) throws Exception {
                System.out.println("afterConnectionEstablished");
            }

            @Override
            public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception {
                System.out.println("handleMessage");
            }

            @Override
            public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
                System.out.println("handleTransportError");
            }

            @Override
            public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throws Exception {
                System.out.println("afterConnectionClosed");
            }

            @Override
            public boolean supportsPartialMessages() {
                return false;
            }
        };
    }

}