package Torello.Browser;

import static Torello.Java.C.BRED;
import static Torello.Java.C.BGREEN_BKGND;
import static Torello.Java.C.BGREEN;
import static Torello.Java.C.RESET;

import Torello.Java.StorageWriter;
import Torello.Java.StrPrint;
import Torello.Java.EXCC;

import Torello.Java.Additional.AsynchronousException;
import Torello.Java.Additional.AppendableSafe;
import Torello.Java.Additional.Promise;

import NeoVisionaries.WebSockets.WebSocketAdapter;
import NeoVisionaries.WebSockets.WebSocket;
import NeoVisionaries.WebSockets.WebSocketException;
import NeoVisionaries.WebSockets.WebSocketFrame;
import NeoVisionaries.WebSockets.ThreadType;

import java.io.IOException;
import java.io.UncheckedIOException;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import javax.json.JsonObject;


// ************************************************************************************************
// ************************************************************************************************
// Chat-GPT wrote the summary below: July 20th, 2025
// ************************************************************************************************
// ************************************************************************************************
// 
// 
// Package-private class that implements the NeoVisionaries WebSocketAdapter interface and serves as
// the receiver for all incoming WebSocket messages from Chrome DevTools. This class is registered
// internally by the WebSocketSender and acts as the delegate for lifecycle events like connection,
// disconnection, errors, and—most importantly—data reception.
//
// The primary responsibility of this class is to handle text-based WebSocket messages and forward
// them to the centralized dispatch logic inside HandleDispatch.handle(...). All incoming JSON
// messages from Chrome (whether events or command responses) are intercepted via the onTextMessage
// override and routed to the appropriate handler using shared references to the active Promise map
// and WebSocketSender instance.
//
// This class is not part of the public API and is not intended for direct use outside of the
// WebSocketSender lifecycle. It acts as an internal wiring layer to cleanly decouple low-level
// WebSocket transport from higher-level message interpretation and routing.

class WSAdapter extends WebSocketAdapter
{
    private final WebSocketSender wss;
    private final ConcurrentHashMap<Integer, Promise<JsonObject, ?>> promises;

    WSAdapter(
            final WebSocketSender wss,
            final ConcurrentHashMap<Integer, Promise<JsonObject, ?>> promises
        )
    {
        this.wss        = wss;
        this.promises   = promises;
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Message Receivers
    // ********************************************************************************************
    // ********************************************************************************************


    @Override
    public void onTextMessage(WebSocket ws, String message)
    { HandleDispatch.handle(message, this.wss, this.promises); }

    @Override
    public void onTextMessage(WebSocket ws, byte[] data)
    {
        System.err.println(
            "data.length: " + data.length + '\n' +
            "Chrome has sent a byte[] Array, but this isn't implemented, and should not occur.\n" +
            "Throwing UnreachableError..."
        );

        throw new Torello.Java.UnreachableError();
    }

    @Override
    public void onDisconnected(
            WebSocket       ws,
            WebSocketFrame  serverCloseFrame,
            WebSocketFrame  clientCloseFrame,
            boolean         closedByServer
        )
    {
        final String            msg = "🔴 [NeoVisionaries] WebSocket DISCONNECTED!\n";
        final AppendableSafe    app = this.wss.app();

        this.wss.raw().append(msg);
        app.append(BGREEN_BKGND + " Socket Disconnected " + RESET + '\n');

        // Reject all pending Promises
        for (Map.Entry<Integer, Promise<JsonObject, ?>> entry : this.promises.entrySet())
        {
            final int                       id      = entry.getKey();
            final Promise<JsonObject, ?>    promise = entry.getValue();

            app.append(
                BGREEN_BKGND + " Cancelling Promise " + RESET +
                " MessageID=" + id + ", Socket Has Closed\n"
            );

            promise.acceptThrowable(
                -1,
                new AsynchronousException
                    ("WebSocket disconnected before receiving a response (MessageID=" + id + ")")
            );
        }

        this.promises.clear();
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // RAW FRAMES
    // ********************************************************************************************
    // ********************************************************************************************

    @Override
    public void onBinaryFrame(WebSocket websocket, WebSocketFrame frame)
    { RAW("🟠", "onBinaryFrame", frame); }

    @Override
    public void onCloseFrame(WebSocket ws, WebSocketFrame frame)
    {
        RAW(
            "🟡",
            "onCloseFrame()",
            "Close-Code: " + frame.getCloseCode() + ", Reason: " + frame.getCloseReason(),
            frame
        );
    }

    @Override
    public void onContinuationFrame(WebSocket websocket, WebSocketFrame frame)
    { RAW("🟠", "onContinuationFrame", frame); }

    @Override
    public void onFrame(WebSocket websocket, WebSocketFrame frame)
    { RAW("🟠", "onFrame", frame); }

    @Override
    public void onPingFrame(WebSocket websocket, WebSocketFrame frame)
    { RAW("🟢", "onPingFrame", "Received-Ping", frame); }

    @Override
    public void onPongFrame(WebSocket websocket, WebSocketFrame frame)
    { RAW("🟢", "onPongFrame", "Received-Pong", frame); }

    @Override
    public void onSendingFrame(WebSocket websocket, WebSocketFrame frame)
    { RAW("🟠", "onSendingFrame", PrintUtil.PTXT(frame), frame); }

    @Override
    public void onTextFrame(WebSocket websocket, WebSocketFrame frame)
    { RAW("🟠", "onTextFrame", PrintUtil.PTXT(frame), frame); }


    // ********************************************************************************************
    // ********************************************************************************************
    // RAW THREADS
    // ********************************************************************************************
    // ********************************************************************************************


    @Override
    public void onThreadCreated(WebSocket websocket, ThreadType threadType, Thread thread)
    { RAW("🟢", "onThreadCreated", "ThreadType=" + threadType + ", Name=" + thread.getName()); }

    @Override
    public void onThreadStarted(WebSocket websocket, ThreadType threadType, Thread thread)
    { RAW("🟢", "onThreadStarted", "ThreadType=" + threadType + ", Name=" + thread.getName()); }

    @Override
    public void onThreadStopping(WebSocket websocket, ThreadType threadType, Thread thread)
    { RAW("🔴", "onThreadStopping", "ThreadType=" + threadType + ", Name=" + thread.getName()); }


    // ********************************************************************************************
    // ********************************************************************************************
    // RAW 
    // ********************************************************************************************
    // ********************************************************************************************


    private void RAW(String emoji, String methodName, String message)
    { RAW(emoji, methodName, message, null); }

    private void RAW(String emoji, String methodName, final WebSocketFrame frame)
    { RAW(emoji, methodName, null, frame); }

    private void RAW(
            final String            emoji,
            final String            methodName,
            final String            message,
            final WebSocketFrame    frame
        )
    {
        final String frameStr = (frame == null) 
            ? ""
            : ", OpCode=" + frame.getOpcode() + ", PayloadLength=" + frame.getPayloadLength();

        final String msgStr = (message == null) ? "" : message;

        this.wss
            .raw()
            .append(emoji + "  ")
            .append('[' + BGREEN + methodName + "(...)" + RESET + frameStr + "]: ")
            .append(msgStr)
            .append('\n');
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // The Error-Checking Handlers
    // ********************************************************************************************
    // ********************************************************************************************


    @Override
    public void onError(WebSocket ws, WebSocketException cause)
    { this.EX(cause, "onError"); }

    @Override
    public void onConnectError(WebSocket ws, WebSocketException cause)
    { this.EX(cause, "onConnectError"); }

    @Override
    public void onFrameError
        (WebSocket ws, WebSocketException cause, WebSocketFrame frame)
    { this.EX(cause, "onFrameError"); }

    @Override
    public void onMessageError
        (WebSocket ws, WebSocketException cause, List<WebSocketFrame> frames)
    { this.EX(cause, "onMessageError"); }

    @Override
    public void onMessageDecompressionError
        (WebSocket ws, WebSocketException cause, byte[] data)
    { this.EX(cause, "onMessageDecompressionError"); }

    @Override
    public void onTextMessageError(WebSocket ws, WebSocketException cause, byte[] data)
    { this.EX(cause, "onTextMessageError"); }

    @Override
    public void onSendError(WebSocket ws, WebSocketException cause, WebSocketFrame frame)
    { this.EX(cause, "onSendError"); }

    @Override
    public void onUnexpectedError(WebSocket ws, WebSocketException cause)
    { this.EX(cause, "onUnexpectedError"); }

    private void EX(Exception e, String handlerMethodName)
    {
        this.wss
            .err()
            .append("🔴 [NeoVisionaries] Error Reported: " + BRED + handlerMethodName + RESET)
            .append('\n')
            .append(EXCC.toString(e))
            .append('\n');

        this.wss.rdpErrorHandler.accept
            (new RDPError("WebSocketAdapter Reported Error: " + handlerMethodName, e));
    }
}