import { Wrapper } from './wrapper'
import {
    Environment,
    Errors,
    Events,
    RPCState,
    Utils,
    type PlayerMp,
} 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: PlayerMp | string, dataRaw: string) => {
                switch (this.environment_) {
                    case Environment.SERVER:
                        server.resolveEmitDestination(
                            player as PlayerMp,
                            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<
        CallbackArguments extends unknown[] = unknown[],
        CallbackReturn extends unknown = unknown,
        EventName extends string = string,
    >(
        eventName: EventName,
        cb: (...args: CallbackArguments) => CallbackReturn,
    ): void {
        Utils.errorUnknownEnvironment(this.environment_)

        this.state_[eventName] = cb
    }

    public unregister<EventName extends string = string>(
        eventName: EventName,
    ): void {
        Utils.errorUnknownEnvironment(this.environment_)

        delete this.state_[eventName]
    }

    public callClient<
        Arguments extends unknown[] = unknown[],
        EventName extends string = string,
    >(eventName: EventName, args?: Arguments): void
    public callClient<
        Arguments extends unknown[] = unknown[],
        EventName extends string = string,
    >(player: PlayerMp, eventName: EventName, args?: Arguments): void
    public callClient(
        playerOrEventName: PlayerMp | string,
        eventNameOrArgs?: string | unknown[],
        args?: unknown[],
    ): void {
        Utils.errorUnknownEnvironment(this.environment_)

        function _is1StParamPlayer(x: unknown): x is PlayerMp {
            return typeof x === 'object'
        }
        function _is2NdParamEventName(x: unknown): x is string {
            return !Array.isArray(x) && typeof x === 'string'
        }

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

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

            const dataRaw = Utils.prepareTransfer(state)

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

        // browser
        if (
            this.environment_ === Environment.BROWSER &&
            !_is1StParamPlayer(playerOrEventName) &&
            !_is2NdParamEventName(eventNameOrArgs)
        ) {
            const state: RPCState = {
                uuid: Utils.generateUUID(),
                eventName: playerOrEventName,
                calledTo: Environment.CLIENT,
                calledFrom: this.environment_,
                knownError: undefined,
                data: eventNameOrArgs,
            }

            const dataRaw = Utils.prepareTransfer(state)

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

    public callServer<
        Arguments extends unknown[] = unknown[],
        EventName extends string = string,
    >(eventName: EventName, args?: Arguments) {
        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<
        Arguments extends unknown[] = unknown[],
        EventName extends string = string,
    >(eventName: EventName, args?: Arguments) {
        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<
        Arguments extends unknown[] = unknown[],
        EventName extends string = string,
    >(eventName: EventName, args?: Arguments) {
        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 }