import { decode, encode } from "./encode_decode_message"
import { Bytes, OnMessage, RTMT } from "./rtmt"

import WebSocket from "ws"
import * as http from 'http';

export class RTMTWS implements RTMT {

    private messageChannels: Map<String, OnMessage>

    private wsServer: WebSocket.Server | null

    public clients = new Map<string, WebSocket>()

    constructor() {
        this.messageChannels = new Map<String, OnMessage>()
        this.wsServer = null
    }

    initWebSocket(server: http.Server, onopen: (userKey : string) => any) {
        const wsServer = new WebSocket.Server({ server })
        this.wsServer = wsServer
        this.clients = new Map<string, WebSocket>()

        wsServer.on("connection", (ws: WebSocket, req: Request) => {
            
            const regexResult = req.url.split(RegExp("\/\?userKey="));
            const clientID = regexResult[1]
            this.clients.set(clientID, ws)
            ws.on("message", (messageBytes: string) => {
                console.log('received: %s', messageBytes);
                this.onWebSocketMessage(clientID, messageBytes)
            })

            ws.on("close", (code: number, reason: string) => {
                console.log("WS Closed! code : " + code + " reason : " + reason);
                this.clients.delete(clientID)
            })

            ws.on("error", (err: Error) => {
                console.log("WS Closed with error! error : " + err.message);
                this.clients.delete(clientID)
            })

            onopen(clientID)
        })

    }

    sendMessage(clientID: string, channel: string, message: Object) {
        if (this.wsServer) {
            const client = this.clients.get(clientID)
            if (client) {
                const data = encode({ channel: channel, message: message })
                console.log("(RTMT) Sending message to channel " + channel);
                client.send(data)
            } else {
                console.log("Client not connected!");
            }
        } else {
            console.log('ws is undefined')
        }
    }

    listenMessage(channel: string, callback: OnMessage) {
        this.messageChannels.set(channel, callback)
    }

    onWebSocketMessage(clientID: string, messageBytes: string) {
        const message = decode(messageBytes)
        console.log(message);
        
        this.onMessage(clientID, message.channel, message.message)

    }

    onMessage(clientID: string, channel: string, message: Object) {
        const callback = this.messageChannels.get(channel)
        if (callback) {
            callback(clientID, message)
        } else {
            console.log("Channel callback not found! " + channel);
        }
    }
}