import { symbolToken, SymbolToken } from '@servicetitan/react-ioc';
import mitt from 'mitt';
import { JSON, Serializable } from './types';

export const EVENT_BUS_TOKEN = symbolToken<EventBus>('EVENT_BUS_TOKEN');

export function typedEventBusToken<EventTypes extends Serializable<EventTypes>>() {
    return symbolToken<EventBus<EventTypes>>('EVENT_BUS_TOKEN');
}

export type EventHandler<EventTypes, Event, T = never> = (
    data: [T] extends [never]
        ? Event extends SymbolToken<infer DataType>
            ? Serializable<DataType>
            : Event extends keyof EventTypes
              ? EventTypes[Event]
              : T
        : Serializable<T>
) => void;

type JobPayload = JSON | void;

export type EventType = string | number | symbol;
export type SymbolTokenEventType<T, U extends EventType = EventType> =
    U extends SymbolToken<any> ? SymbolToken<T> : U;

export type JobEventHandler<Event> = (defer: {
    /**
     * Successfully complete a job.
     * @param result The value to return from the successfully completed job.
     */
    resolve(
        ...result: Event extends SymbolToken<infer ResultType>
            ? undefined extends ResultType
                ? [Serializable<ResultType>?]
                : [Serializable<ResultType>]
            : [JobPayload]
    ): void;
    /**
     * Fail a job.
     * @param reason The error to return from the failed job.
     */
    reject(reason?: string | Error): void;
}) => void;

export class EventBus<EventTypes extends Serializable<EventTypes> = never> {
    job = {
        /**
         * Register a job event handler. Jobs event handlers return a result or an error.
         * @param event The job event to handle.
         * @param handler The handler to call when the event occurs. This handler is passed a `resolve` callback to return a successful result, and a `reject` callback to return an error.
         */
        on: <Event extends SymbolToken<any> | keyof EventTypes>(
            event: Event,
            handler: JobEventHandler<Event>
        ) => {
            this.validateEvent(event);
            this.emitter.on(event, handler);
        },

        /**
         * Deregister a job event handler.
         * @param event The previously registered event.
         * @param handler The previously registered handler.
         */
        off: <Event extends SymbolToken<any> | keyof EventTypes>(
            event: Event,
            handler: JobEventHandler<Event>
        ) => {
            this.emitter.off(event, handler);
        },

        /**
         * Send a job event.
         * @param event The event to send.
         * @returns a Promise that resolves or rejects depending on whether the job completes successfully.
         */
        emit: <Event extends SymbolToken<any> | keyof EventTypes>(event: Event) => {
            this.validateEvent(event);
            return new Promise<
                Event extends SymbolToken<infer ResultType> ? Serializable<ResultType> : JobPayload
            >((resolve, reject) => {
                this.emitter.emit(event, {
                    resolve,
                    reject: (reason?: string | Error) => {
                        if (typeof reason === 'string' || reason instanceof Error) {
                            reject(reason);
                        } else {
                            reject();
                        }
                    },
                });
            });
        },
    };

    private emitter = mitt<any>();

    /**
     * Register an event handler.
     * @param event The event to handle.
     * @param handler The handler to call when the event occurs.
     */
    on = <T extends Serializable<T> = never, Event extends SymbolToken<T> | keyof EventTypes = any>(
        event: SymbolTokenEventType<T, Event>,
        handler: EventHandler<EventTypes, Event, T>
    ) => {
        this.validateEvent(event);
        this.emitter.on(event, handler);
    };

    /**
     * Deregister an event handler.
     * @param event The previously registered event.
     * @param handler The previously registered handler.
     */
    off = <
        T extends Serializable<T> = never,
        Event extends SymbolToken<T> | keyof EventTypes = any,
    >(
        event: SymbolTokenEventType<T, Event>,
        handler: EventHandler<EventTypes, Event, T>
    ) => {
        this.emitter.off(event, handler);
    };

    /**
     * Send an event.
     * @param event The event to send.
     * @param data The data to pass to the event's handler.
     */
    emit = <T extends Serializable<T>, Event extends SymbolToken<T> | keyof EventTypes = any>(
        event: SymbolTokenEventType<T, Event>,
        ...data: Event extends SymbolToken<any>
            ? undefined extends T
                ? [T?]
                : [T]
            : [EventTypes] extends [never]
              ? [T?]
              : Event extends keyof EventTypes
                ? undefined extends EventTypes[Event]
                    ? [EventTypes[Event]?]
                    : [EventTypes[Event]] extends [never]
                      ? []
                      : [EventTypes[Event]]
                : never
    ) => {
        this.validateEvent(event);
        this.emitter.emit(event, data[0]);
    };

    private validateEvent(event: any) {
        if (process.env.NODE_ENV === 'production') {
            return;
        }

        const name = this.getName(event);
        if (name === undefined || /^[^:]+:.+/.test(name) || allowListedEvents.has(name)) {
            return;
        }

        throw new Error('event must have format {module}:{name}');
    }

    private getName(event: any) {
        if (typeof event === 'string') {
            return event;
        }
        if (typeof event === 'symbol') {
            return Symbol.keyFor(event) ?? '';
        }
        return undefined;
    }
}

const allowListedEvents = new Set([
    ':widgets:message',
    '[EH] Module Link Clicked',
    '[EH] Module Loaded',
    '[internal] reset',
    'blink',
    'CLOSE_COMPONENT',
    'CLOSE_JOB_EDIT_FLYOUT',
    'company-profile-request-save',
    'company-profile-saved-error',
    'company-profile-saved',
    'dismiss-discrepancy-event',
    'dismiss-discrepancy-map-event',
    'dispatch-JobEditFlyout-fetchData',
    'DRAWER_CREATED_CUSTOMER',
    'employees-emails-processed',
    'employees-request-save',
    'employees-saved-error',
    'employees-saved',
    'ium-ep-cancel-changes',
    'ium-ep-form-can-be-submitted-change',
    'ium-ep-save-changes',
    'loaded',
    'MESSAGE_TECHNICIAN',
    'my-custom-event',
    'NEW_EVENT',
    'NonJobEventSelectedEvent',
    'ON_WIDGET_INIT',
    'OPEN_ASSIST_SCREEN',
    'OPEN_CREATE_CUSTOMER_DRAWER',
    'OPEN_DC_SIDE_PANEL_COMPONENT',
    'OPEN_JOB_EDIT_FLYOUT',
    'OPEN_RESCHEDULE_FLYOUT',
    'open-troubleshooter',
    'resolve-discrepancy-map-event',
    'restore-discrepancy-event',
    'setLabel',
    'SHOW_POP_UP_MESSAGE',
    'TEAMS_SELECTED',
    'technicians-emails-processed',
    'technicians-request-save',
    'technicians-saved-error',
    'technicians-saved',
    'timesheet-activity-saved',
    'TOGGLE_DC_SIDE_PANEL_COMPONENT',
    'updateUserEmail',
    'VIEW_NON_JOB_EVENT',
    'visibility',
]);