"use strict";

import WebSocket from 'ws';
import { getAuthPayload } from "./authPayload";
import { ipcEmit } from './helpers';

let socket: WebSocket;

const socketUrl = "ws://127.0.0.1:8760"

const _connectionCheckTimeout = 4000;
const _reconnectTimeout = 1000;
let _connectionCheckInterval: ReturnType<typeof setTimeout>;


// Run every time we want to connect to backend.
export default function useWebSockets(
    receiveCallback: (s: string) => void,
    openCallback?: () => void
) {

    // Returns bool (sucess or fail).
    const sendMessage = (data: any) => {
        console.log("WS:Sending message: ", data)

        if (socket.readyState !== 1) {
            return false
        }

        else {
            socket.send(JSON.stringify(data))
            return true
        }

    }

    const send = async (data: Record<string, any>): Promise<boolean> => (
        new Promise((resolve, reject) => {
            if (socket.readyState !== 1) {
                reject(false);
            }
            socket.send(JSON.stringify(data))
            resolve(true);

        }))


    const onOpen = (_event: WebSocket.OpenEvent) => {

        console.log("WS:Connected to WS Server!");
        const jwt = getAuthPayload();
        socket.send(JSON.stringify(jwt));

        // ping server
        _connectionCheckInterval = setInterval(() => {

            if (socket) socket.ping(null, true, (e: Error) => {
                if (e) {
                    ipcEmit('connection-alive', false);
                    socket.close();
                    setTimeout(createSocket, 1000);
                }
            });

        }, _connectionCheckTimeout);

        if (openCallback) openCallback();

    }

    const onServerMessage = (event: WebSocket.MessageEvent) => {

        console.log("WS:Message received: ", event.data);

        receiveCallback(event.data.toString())

    }

    const onClose = (event: WebSocket.CloseEvent) => {
        console.log("WS:Socket closed normally.", event.wasClean)

        clearInterval(_connectionCheckInterval);

        if (!event.wasClean) {
            ipcEmit('connection-alive', false);
            setTimeout(createSocket, 1000);
        }
    }

    // Reconnect automatically on error.
    const onError = (event: WebSocket.ErrorEvent) => {
        console.log("WS:WebSocket error: ", event.message);
    }


    const createSocket = (): WebSocket => {

        if (_connectionCheckInterval) clearInterval(_connectionCheckInterval);

        socket = new WebSocket(socketUrl);

        // Add listeners.
        socket.addEventListener("open", onOpen);
        socket.addEventListener("message", onServerMessage);
        socket.addEventListener("close", onClose);
        socket.addEventListener("error", onError);
        socket.addEventListener("pong", () => {
            ipcEmit('connection-alive', true);
        });

        return socket;

    }

    return {
        createSocket,
        sendMessage,
        send
    }

}