import { Wrapper } from './wrapper'
import { Environment, Errors, Events, RPCState, Utils } from './utils'
import { server } from './server'
import { client } from './client'
import { browser } from './browser'

class Rpc extends Wrapper {
    constructor() {
        super()

        if (this.environment_ === Environment.UNKNOWN)
            throw new Error(Errors.UNKNOWN_ENVIRONMENT)

        mp.events.add(
            Events.EVENT_LISTENER,
            async (player: any, dataRaw: string) => {
                if (!dataRaw) throw new Error(Errors.NO_DATA)

                switch (this.environment_) {
                    case Environment.SERVER:
                        server.resolveEmitDestination(player, dataRaw)
                        break

                    case Environment.CLIENT:
                        dataRaw = player
                        client.resolveEmitDestination(dataRaw)
                        break

                    case Environment.BROWSER:
                        dataRaw = player
                        browser.resolveEmitDestination(dataRaw)
                        break

                    default:
                        void { player, dataRaw }
                        break
                }
            },
        )
    }

    public register(
        eventName: string,
        cb: (...args: unknown[]) => unknown,
    ): void {
        Utils.errorUnknownEnvironment(this.environment_)

        this.state_[eventName] = cb
    }

    public unregister(
        eventName: string
    ): void {
        Utils.errorUnknownEnvironment(this.environment_)

        delete this.state_[eventName]
    }

    public callClient(eventName: string, args: unknown[]) {
        Utils.errorUnknownEnvironment(this.environment_)

        const state: RPCState = {
            uuid: Utils.generateUUID(),
            eventName,
            calledTo: Environment.CLIENT,
            calledFrom: this.environment_,
            knownError: undefined,
            data: args,
        }

        const dataRaw = Utils.prepareTransfer(state)

        mp.events.call(Events.EVENT_LISTENER, dataRaw)
    }

    public callServer(eventName: string, args: unknown[]) {
        Utils.errorUnknownEnvironment(this.environment_)

        const state: RPCState = {
            uuid: Utils.generateUUID(),
            eventName,
            calledTo: Environment.SERVER,
            calledFrom: this.environment_,
            knownError: undefined,
            data: args,
        }

        const dataRaw = Utils.prepareTransfer(state)

        mp.events.call(Events.EVENT_LISTENER, dataRaw)
    }

    public callBrowser(eventName: string, args: unknown[]) {
        Utils.errorUnknownEnvironment(this.environment_)

        const state: RPCState = {
            uuid: Utils.generateUUID(),
            eventName,
            calledTo: Environment.BROWSER,
            calledFrom: this.environment_,
            knownError: undefined,
            data: args,
        }

        const dataRaw = Utils.prepareTransfer(state)

        mp.events.call(Events.EVENT_LISTENER, dataRaw)
    }

    public call(eventName: string, args: unknown[]) {
        Utils.errorUnknownEnvironment(this.environment_)

        let state: RPCState = {
            uuid: Utils.generateUUID(),
            eventName,
            calledTo: this.environment_,
            calledFrom: this.environment_,
            knownError: undefined,
            data: args,
        }

        state = this.verifyEvent_(state)
        if (state.knownError) {
            this.triggerError_(state, state.knownError)
            return
        }
    }
}

const rpc = new Rpc()
export { rpc }