import {EMPTY, Observable} from "rxjs";
import {catchError, map, switchMap} from "rxjs/operators";
import {ActionType, ofType} from "deox";
import {actions} from "./iris.action";
import {IrisClientType} from "..";

export const createAutoIrisChannel = (irisClient: IrisClientType) => (
    actions$: any,
): Observable<ActionType<typeof actions.createdIrisChannel>> =>
    irisClient.connection.createChannel().pipe(map(actions.createdIrisChannel));

export const createIrisChannel = (irisClient: IrisClientType) => (
    actions$: Observable<ActionType<typeof actions.createIrisChannel>>,
): Observable<ActionType<typeof actions.createdIrisChannel>> =>
    actions$.pipe(
        ofType(actions.createIrisChannel),
        switchMap(() => irisClient.connection.createChannel()),
        map( it => actions.createdIrisChannel(it))
);

export const linkPhone = (irisClient: IrisClientType) => (
    actions$: Observable<ActionType<typeof actions.linkPhoneNumber>>,
): Observable<ActionType<typeof actions.linkedPhoneNumber>> =>
    actions$.pipe(
        ofType(actions.linkPhoneNumber),
        switchMap(it => irisClient.connection.connectWithPhoneNumber(it.payload.channel, it.payload.phoneNumber)),
        map( it => actions.linkedPhoneNumber(it))
    );

export const connectIrisWs = (irisClient: IrisClientType) => (
    actions$: Observable<ActionType<typeof actions.createdIrisChannel>>,
): Observable<ActionType<typeof actions.connectedIrisChannel>> =>
    actions$.pipe(
        ofType(actions.createdIrisChannel),
        map(session => irisClient.connection.websocket(session.payload.channel)),
        map(actions.connectedIrisChannel)
    );

export const listenIrisMessage = (irisClient: IrisClientType) => (
    actions$: Observable<ActionType<typeof actions.connectedIrisChannel>>,
): Observable<ActionType<| typeof actions.receivedAuthIrisResponse
    | typeof actions.receivedSignIrisResponse
    | typeof actions.error>> => {
    return actions$.pipe(
        ofType(actions.connectedIrisChannel),
        switchMap(it =>
            it.payload.$subject.pipe(
                map(it => {
                    if (it.action == "AUTH") {
                        return actions.receivedAuthIrisResponse(it.payload.jwt!!);
                    } else if (it.action == "SIGN") {
                        return actions.receivedSignIrisResponse(
                            it.payload.signature!!
                        );
                    } else {
                        return actions.error(it);
                    }
                }),
                catchError((err,caught) =>{
                    console.log(err);
                    return caught
                }),
            )
        )
    );
};

export const notifyLoggedIn = (irisClient: IrisClientType) => (
    actions$: Observable<ActionType<typeof actions.receivedAuthIrisResponse>>,
): Observable<ActionType<typeof actions.loggedIn>> =>
    actions$.pipe(
        ofType(actions.receivedAuthIrisResponse),
        map(it => actions.loggedIn({
                jwt: it.payload.jwt
            })
        ),
    );

export const sendIrisAuthMessage = (irisClient: IrisClientType) => (
    actions$: Observable<ActionType<typeof actions.connectedIrisChannel>>,
): Observable<ActionType<never>> =>
    actions$.pipe(
        ofType(actions.connectedIrisChannel),
        map(it => {
            const irisSubject = it.payload.$subject;
            const authMessage = irisClient.messageBuilder.authMessage();
            irisSubject.next(authMessage);
        }),
        switchMap(() => EMPTY)
    );

export const sentIrisSignMessage = (irisClient: IrisClientType) => (
    actions$: Observable<ActionType<typeof actions.sendIrisSignMessage>>,
): Observable<never> =>
    actions$.pipe(
        ofType(actions.sendIrisSignMessage),
        map((it) => {
            const authMessage = irisClient.messageBuilder.authMessage();
            it.payload.$subject.next(authMessage);
        }),
        switchMap(() => EMPTY)
    );

export const removeIrisChannelOnLoggout = (irisClient: IrisClientType) => (
    actions$: Observable<ActionType<typeof actions.logout>>,
): Observable<ActionType<never>> =>
    actions$.pipe(
        ofType(actions.logout),
        map(it => it.payload.channel ? irisClient.connection.deleteChannel(it.payload.channel): EMPTY),
        switchMap(() => EMPTY)
    );

export const epics = (irisClient: IrisClientType) => [
    createAutoIrisChannel(irisClient),
    createIrisChannel(irisClient),
    connectIrisWs(irisClient),
    listenIrisMessage(irisClient),
    sendIrisAuthMessage(irisClient),
    sentIrisSignMessage(irisClient),
    notifyLoggedIn(irisClient),
    linkPhone(irisClient),
    removeIrisChannelOnLoggout(irisClient)
];