package Torello.Browser;


import javax.json.*;
import java.io.*;

import NeoVisionaries.WebSockets.*;

import Torello.Java.*;
import Torello.Java.Additional.*;

import static Torello.Java.C.*;

import java.util.TreeMap;
import java.util.List;
import java.lang.reflect.Constructor;
import java.util.function.Consumer;

/**
 * This class implements a connection to a Web-Browser using the Remote Debug Protocol over
 * Web-Sockets.
 * 
 * <H3 STYLE='background: black; color: white; padding: 0.5em;'>Browser Remote Debug Protocol
 * Connection Class</H3>
 * 
 * <BR />Java is capable of communicating with either a Headless instance of Google Chrome - <I>or
 * any browser that implements the Remote Debuggin Protocol</I>.  It is not mandatory to run the
 * browser in headless mode, but it is more common.
 */
@SuppressWarnings({"rawtypes", "unchecked"})
public class WebSocketSender implements Sender<String>
{
    // The Browser Connection
    private final WebSocket webSocket;

    private Consumer<Object> eventHandler = null;

    /** A Verbose Flag.  This field is {@code public}, and may be set as needed.. */
    public boolean QUIET;

    /**
     * An output printer.  This field is {@code public}, and may be set as needed.
     */
    public StorageWriter sw = null;

    // Stores the lists of promises
    private TreeMap<Integer, Promise<JsonObject, ? extends Object>> promises = new TreeMap<>();

    /** Closes the {@link WebSocket} connection to the Browser's Remote Debug Port. */
    public void disconnect() { webSocket.disconnect(); }


    // ********************************************************************************************
    // ********************************************************************************************
    // Web-Socket Message Handler
    // ********************************************************************************************
    // ********************************************************************************************


    // Top-Level Handler
    private void HANDLE(String message)
    {
        if (! QUIET) if (sw != null) sw.println
            (BYELLOW + "Received JSON Message From Chrome:\n\t" + RESET + message);

        JsonObject jo = Json
            .createReader(new StringReader(message))
            .readObject();

        int     idReceived  = jo.getInt("id", -1);
        String  method      = jo.getString("method", null);

        // If the WebSocket Message had an ID, then that ID should map to one of the Promises
        // stored in the TreeMap

        if (idReceived != -1)
        {
            Promise<JsonObject, ? extends Object> promise = promises.remove(idReceived);

            // THIS LINE DOESN'T WORK BECAUSE: The NeoVisionaries thing doesn't seem to
            // "bubble-up" exceptions at all...  I guess it catches them, and just sort
            // of hangs...

            if (promise == null)
            {
                System.out.println(
                    "ID Received: [" + idReceived + "], is unknown, or already handled.\n" +
                    "Throwing Exception, WebSockets Package will Catch This."
                );

                throw new AsynchronousException
                    ("ID Received: [" + idReceived + "], is unknown, or already handled.");
            }

            synchronized (promise)
                { HANDLE_PROMISE(idReceived, promise, jo); promise.notifyAll(); }
        }

        else if (method != null) HANDLE_EVENT(jo, method);

        else

            sw.println(
                BRED + "UNRECOGNIZED MESSAGE RECEIEVED\n\t" + RESET + '\t' +
                jo.toString()
            );
    }

    // The Browser has sent a message about a particular Send-Request.  Report this response
    // to the promise.
    private final void HANDLE_PROMISE
        (int idReceived, Promise<JsonObject, ?> promise, JsonObject jo)
    {
        if (! QUIET) if (sw != null) sw.println
            (BCYAN + "RESPONSE RECEIVED - PROCESSING " + RESET + "(ID: " + idReceived + ")");

        // Check for errors first
        JsonObject error = jo.getJsonObject("error");

        if (error != null)
        {
            int     code            = error.getInt("code", -1);
            String  errorMessage    = error.getString("message", "-");

            if (! QUIET) if (sw != null) sw.println
                (BRED + "RECEIVED ERROR RESPONSE" + RESET + " - EXITING...");

            promise.acceptError(code, errorMessage);
        }

        else
        {
            JsonObject commandResultJSON = jo.getJsonObject("result");

            if (commandResultJSON == null)
                throw new JsonException("Response JSON String did not contain a response.");

            promise.acceptResponse(commandResultJSON);
        }
    }

    // A Browser Generated Event has fired.  Report this even.
    private void HANDLE_EVENT(JsonObject jo, String eventName)
    {
        try
        {
            eventName = eventName.replace(".", "$");

            // Convert the class-name from a string to a fully-qualified class name
            String className = BRDPC.getEventClassName(eventName);

            if (className == null)
            {
                sw.println(
                    "Un-Typed Browser Event Received:\n" +

                    StrIndent.indent(

                        // NOTE: This is an "imperative" when you request long-winded HTML,
                        //       this method will otherwise print hundreds, or even thousands of
                        //       lines of HTML to the screen without this.
                        //
                        // null ==> abbrevStr, 100 ==> Max-Line-Len, 10 ==> Max-Lines,
                        // true ==> Compact-Consecutive-Blank-Lines
    
                        StrPrint.widthHeightAbbrev(jo.toString(), null, 100, 10, true),

                        // 4 ==> Indent by four space chars
                        4
                    ));

                return;
            }

            Class<?> c = Class.forName("Torello.Browser." + className);

            if (c == null)
            {
                sw.println(
                    "Failed to load Event-Class: " +
                    '[' + BCYAN + "Torello.Browser." + className + RESET + ']'
                );

                return;
            }

            Constructor<?>  ctr     = c.getConstructor(JsonObject.class);
            JsonObject      params  = jo.getJsonObject("params");
            Object          event = null;

            try 
                { event = ctr.newInstance(params); }

            catch (Exception e)
            {
                sw.println(
                    "Failed to build event-class using constructor: " + 
                    '[' + BCYAN + "Torello.Browser." + className + RESET + "\n" +
                    "Received JSON:\n" +
                    StrIndent.indent(jo.toString(), 4)
                );

                return;
            }

            if ((! QUIET) || (eventHandler == null)) if (sw != null) sw.println(
                BCYAN + "Event Received:\n" + RESET +
                "        Event-Class: " + c.getName() + '\n' +
                BPURPLE + StrIndent.indent(event.toString(), 8) + RESET
            );

            if (eventHandler != null) eventHandler.accept(event);
            else if (sw != null) sw.println("No Event-Handler, Event Ignored.");
        }

        catch (Exception e)
        {
            if (! QUIET) if (sw != null) sw.println
                (BRED + "EVENT THINGY FAILED\n" + RESET + EXCC.toString(e));

            System.exit(1);
        }
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Class Constructor
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * Opens a Connection to a Web Browser using a Web-Socket.  This class will now be
     * ready to accept {@link #send(int, String, Promise)} messages to the browser.
     * 
     * @param url This is a {@code URL} that is generated by the browser, and has a base
     * {@code URL} that is just {@code 127.0.0.1}, followed by a <B STYLE='color:red'>port
     * number</B>.  There will also be an <B STYLE='color:red;'>identifier-code</B>.
     * 
     * @throws IOException Throws if there are problems connecting the socket.
     * 
     * @throws WebSocketException Throws if the NeoVisionaries Package encounters a problem
     * building the socket connection.
     */
    public WebSocketSender(String url, boolean quiet, Consumer<Object> eventHandler)
        throws IOException, WebSocketException
    {
        final WebSocketListener webSocketListener = new WSAdapter();

        this.QUIET          = quiet;
        this.eventHandler   = eventHandler;

        this.webSocket = new WebSocketFactory()
            .createSocket(url)
            .addListener(webSocketListener)
            .connect();
    }

    private class WSAdapter extends WebSocketAdapter
    {
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Message Receivers
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        @Override
        public void onTextMessage(WebSocket ws, String message)
        { HANDLE(message); }

        @Override
        public void onTextMessage(WebSocket ws, byte[] data)
        {
            System.out.println("data.length: " + data.length);
            Q.BP("A Data-Text Message has been received... Exit or Continue?");
        }


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

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

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

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

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

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

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

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

        private void EX(Exception e, String handlerMethodName)
        {
            System.out.println(
                BRED + handlerMethodName + RESET + "(WebSocket, WebSocketExceptionn" +
                e.toString()
            );

            e.printStackTrace();
        }
    }

    // ********************************************************************************************
    // ********************************************************************************************
    // "Send" method implementation of this Functional Interface
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * This method is the implementation-method for the {@link Sender} Functional-Interface.  This
     * message accepts a <B STYLE='color; red;'>Request &amp; ID</B> pair, and then transmits that
     * request to a Browser's Remote-Debugging Port over the {@code WebSocket}.  It keeps the
     * {@link Promise} that was created by the {@link Script} that sent this request, and saves
     * that {@code Promise} until the Web-Socket receives a response about the request.
     * 
     * @param requestID This may be any number.  It is used to map requests sent over the Web
     * Socket to responses received from it.
     * 
     * @param requestJSON This is the JSON Method Request sent to the Browser
     * 
     * @param promise This is a {@code Promise} which is automatically generated by the 
     * {@link Script} object that is sending the request.
     */
    public void send(int requestID, String requestJSON, Promise promise)
    {
        synchronized (promise)
        {
            promises.put(requestID, promise);

            // Print the request-message that is about to be sent, and then send it.
            if (! QUIET) if (sw != null)
                sw.println(BYELLOW + "Sending JSON:\n\t" + RESET + requestJSON);

            try
                { webSocket.sendText(requestJSON); }

            catch (Exception e)
            {
                throw new AsynchronousException(
                    "When attempting to send a JSON Request, an Exception was thrown:\n" + 
                    e.getMessage() + "\nSee Exception getCause() for details.", e
                );
            }
        }
    }
}