import { IEventHandle, INextEvent, InternalType, EventType } from "../types";
import { Processor } from "../Processor";
import { isPromise } from "../util/isPromise";
import { isInternalType } from "../util/isInternaType";

export const NextEvent: IEventHandle = (processor: Processor, event: INextEvent) => {
    const elementId = event.elementId;
    const state = processor.getElementStateById(event.elementId);
    const { callbacksManager, eventsManager } = processor.locator;
    const isPromiseResult = isPromise(event.value);
    const isCallResult = isInternalType(event.value, InternalType.Call);
    const isSubscribeResult = isInternalType(event.value, InternalType.Subscribe);
    if (isPromiseResult) {
        event.value
            .then(eventsManager.createEvent(elementId, EventType.PromiseThen, {})[1])
            .catch(eventsManager.createEvent(elementId, EventType.PromiseCatch, {})[1]);
    } else if (isSubscribeResult) {
        const subscriptionElementId = event.value.elementId;
        const subscriptionElementState = processor.getElementStateById(subscriptionElementId);
        subscriptionElementState.observer.next = state.observer.next
            ? callbacksManager.createLinkToCallback(state.observer.next)
            : undefined;
        subscriptionElementState.observer.error = state.observer.error
            ? callbacksManager.createLinkToCallback(state.observer.error)
            : undefined;
        subscriptionElementState.observer.complete = state.observer.complete
            ? callbacksManager.createLinkToCallback(state.observer.complete)
            : undefined;
    } else if (isCallResult) {
        if (state.currentCall && state.stack.length === state.tickState.stack.length) {
            const callState = processor.getElementStateById(state.currentCall.elementId);
            if (!state.returnEventId) {
                state.returnEventId = eventsManager.createEvent(elementId, EventType.Next, {})[0];
            }
            callState.observer.next = callbacksManager.createLinkToCallback(state.returnEventId);
        }
    } else if (!(typeof event.value === "symbol" && Symbol.for("never") === event.value)) {
        const next = state.observer && state.observer.next;
        if (next) {
            const nextCallback = callbacksManager.getCallback(next);
            nextCallback(event.value);
        }
    }
    // console.log(event.type, state.effects.length, state.subscriptions.length, state.currentCall);
    if (
        !isSubscribeResult &&
        !isPromiseResult &&
        !isCallResult &&
        state.effects.length === 0 &&
        state.subscriptions.length === 0 &&
        !state.currentCall
    ) {
        eventsManager.triggerEvent({
            elementId,
            params: {},
            type: EventType.Complete,
            value: undefined,
        });
    }
    return false;
};