import { tsLog } from '../logger/logger'

export type MessageNum = {
    firstNum: number
    secondNum: number
    uniNum: number
    name: string
    obj: any
}

export type MessageHandler = {
    callback: (caller: any, data: any) => void
    caller: any
    msgNum: MessageNum
}

let messageNameNumMap: Map<string, MessageNum> = new Map<string, MessageNum>()
let messageNumHandlerMap: Map<number, MessageHandler> = new Map<number, MessageHandler>()
let messageNumLogFilterMap: Map<number, boolean> = new Map<number, boolean>()

export function messageUniNum(firstNum: number, secondNum: number): number {
    let num = firstNum * 100000 + secondNum
    return num
}

export function registerMessageNameNum(name: string, firstNum: number, secondNum: number, obj?: any): boolean {
    let uniNum = messageUniNum(firstNum, secondNum)
    if (messageNameNumMap.has(name)) {
        tsLog.Logger.errorf('tsNet.registerMessageNameNum [{0},{1},{2}] err: duplicate exist', firstNum, secondNum, name)
        return false
    }
    tsLog.Logger.debugf('tsNet.registerMessageNameNum [{0},{1},{2},{3}]', firstNum, secondNum, name, uniNum)
    messageNameNumMap.set(name, { firstNum: firstNum, secondNum: secondNum, uniNum: uniNum, name: name, obj: obj })
    return true
}

export function registerMessageHandler(name: string, callback: (caller: any, data: any) => void, caller: any = null): boolean {
    let msgNum = messageNameNumMap.get(name)
    if (!msgNum) {
        tsLog.Logger.errorf('tsNet.registerMessageHandler {0} err: invalid MessageNum[{1}]', name, msgNum)
        return false
    }
    if (messageNumHandlerMap.has(msgNum.uniNum)) {
        tsLog.Logger.errorf('tsNet.registerMessageHandler [{0},{1},{2}] err: duplicate exist', msgNum.firstNum, msgNum.secondNum, name)
        return false
    }
    tsLog.Logger.debugf('tsNet.registerMessageHandler {0}', name)
    messageNumHandlerMap.set(msgNum.uniNum, { callback: callback, caller: caller, msgNum: msgNum })
    return true
}

export function unregisterMessageHandler(name: string): boolean {
    let msgNum = messageNameNumMap.get(name)
    if (!msgNum) {
        tsLog.Logger.errorf('tsNet.unregisterMessageHandler {0} err: invalid MessageNum[{1}]', name, msgNum)
        return false
    }
    if (!messageNumHandlerMap.has(msgNum.uniNum)) {
        tsLog.Logger.errorf('tsNet.unregisterMessageHandler [{0},{1},{2}] err: does not exist', msgNum.firstNum, msgNum.secondNum, name)
        return false
    }
    tsLog.Logger.debugf('tsNet.unregisterMessageHandler {0}', name)
    messageNumHandlerMap.delete(msgNum.uniNum)
    return true
}

export function registerMessageLogFilter(name: string): void {
    tsLog.Logger.debugf('tsNet.registerMessageLogFilter {0}', name)
    let msgNum = messageNameNumMap.get(name)
    if (!msgNum) {
        tsLog.Logger.errorf('tsNet.registerMessageLogFilter {0} err: invalid MessageNum[{1}]', name, msgNum)
        return
    }
    messageNumLogFilterMap.set(msgNum.uniNum, true)
}

export function getMessageNum(name: string): MessageNum {
    return messageNameNumMap.get(name)
}

export function getMessageHandler(uniNum: number): MessageHandler {
    return messageNumHandlerMap.get(uniNum)
}

export function messageLogFilter(uniNum: number): boolean {
    return messageNumLogFilterMap.has(uniNum)
}