import { Wrapper } from './wrapper'
import type { Player, PlayerServer } from './utils'
import { Environment, Errors, Events, RPCState, Utils } from './utils'

import { server } from './server'
import { client } from './client'
import { browser } from './browser'

export { server } from './server'
export { client } from './client'
export { browser } from './browser'

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

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

        mp.events.add(
            Events.LOCAL_EVENT_LISTENER,
            async (player: Player, dataRaw: string) => {
                switch (this.environment_) {
                    case Environment.SERVER:
                        server.resolveEmitDestination(player, dataRaw)
                        break

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

                    case Environment.BROWSER:
                        dataRaw = player as string
                        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(
        playerOrEventName: Player,
        eventNameOrArgs: string | unknown[],
        args?: unknown[],
    ) {
        Utils.errorUnknownEnvironment(this.environment_)

        // client
        if (this.environment_ === Environment.CLIENT) {
            this.call(playerOrEventName as string, args as unknown[])
            return
        }

        // server
        if (this.environment_ === Environment.SERVER) {
            const state: RPCState = {
                uuid: Utils.generateUUID(),
                eventName: eventNameOrArgs as string,
                calledTo: Environment.CLIENT,
                calledFrom: this.environment_,
                knownError: undefined,
                data: args as unknown[],
            }

            const dataRaw = Utils.prepareTransfer(state)

            ;(playerOrEventName as PlayerServer).call(
                Events.LOCAL_EVENT_LISTENER,
                [dataRaw],
            )
            return
        }

        // browser
        if (this.environment_ === Environment.BROWSER) {
            const state: RPCState = {
                uuid: Utils.generateUUID(),
                eventName: playerOrEventName as string,
                calledTo: Environment.CLIENT,
                calledFrom: this.environment_,
                knownError: undefined,
                data: eventNameOrArgs as unknown[],
            }

            const dataRaw = Utils.prepareTransfer(state)

            mp.trigger(Events.LOCAL_EVENT_LISTENER, dataRaw)
            return
        }
    }

    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,
        }

        if (state.calledFrom === Environment.SERVER) {
            this.callSelf(state)
        } else {
            const dataRaw = Utils.prepareTransfer(state)

            mp.events.call(Events.LOCAL_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,
        }

        if (state.calledFrom === Environment.BROWSER) {
            this.callSelf(state)
        } else {
            const dataRaw = Utils.prepareTransfer(state)

            mp.events.call(Events.LOCAL_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,
        }

        this.callSelf(state)
    }

    private callSelf(state: RPCState) {
        state = this.verifyEvent_(state)
        if (state.knownError) {
            this.triggerError_(state, state.knownError)
            return
        }

        this.state_[state.eventName](...state.data)
    }
}

const rpc = new Rpc()
export { rpc }