call-sdk/packages/core/lib/useCallSdk.ts

import {useEffect, useReducer} from 'react';
import {Agent, GenericObject, StateType} from "./types.ts";
import IAdapter from "@universal-call-sdk/common/lib/Interfaces/IAdapter.ts";
import MetricsProcessor from "@universal-call-sdk/common/lib/utils/metricsProcessor.ts";
import ClickStreamProcessor from "@universal-call-sdk/common/lib/utils/clickStreamProcessor.ts";
import noop from "@universal-call-sdk/common/lib/utils/noop.ts";
import {CALL_STATES} from "@universal-call-sdk/adapter-ameyo/lib/types.ts";


enum actionTypes {
    CALL_INCOMING = 'CALL_INCOMING',
    CALL_CONNECTED = 'CALL_CONNECTED',
    CALL_DISCONNECTED = 'CALL_DISCONNECTED',
    CALL_REJECTED = 'CALL_REJECTED',
    CALL_MUTED = 'CALL_MUTED',
    CALL_UNMUTED = 'CALL_UNMUTED',
}

type Actions = {
    type: actionTypes,
    payload: GenericObject
}

function reducer(state: StateType, action: Actions): GenericObject {
    if (action.type === actionTypes.CALL_INCOMING) {
        return {
            ...state,
            connectedCustomerdata: action.payload,
            isRinging: true
        }
    }
    if (action.type === actionTypes.CALL_CONNECTED) {
        return {
            ...state,
            isCallConnected: true
        }
    }

    if(action.type === actionTypes.CALL_DISCONNECTED) {
        return {
            ...state,
            connectedCustomerData: {},
            isCallDisconnected: true
        }
    }
    if(action.type === actionTypes.CALL_REJECTED) {
        return {
            connectedCustomerData: {},
            isRinging: false
        }

    }
    if(action.type === actionTypes.CALL_MUTED) {
        return {
            ...state,
            isMuted: true
        }
    }
    if(action.type === actionTypes.CALL_UNMUTED) {
        return {
            ...state,
            isMuted: false
        }
    }
   return state;
}


const initialState: StateType = {
    connectedCustomerdata: {},
    isRinging: false,
    isCallConnected: false,
    isCallDisconnected: false,
    callStartTime: Date.now(),
}

let adapter: IAdapter

function UseCallSdk({AdapterClass, adapterOptions, metricsConfig, clickStreamConfig}: {
    AdapterClass: new (adapterOptions: IAdapter) => IAdapter,
    adapterOptions: IAdapter,
    metricsConfig?: {
        isMetricEnabled: boolean,
        metricFlowName: string,
        metricUrl: string,
        metricTransporter: (metricPayload: GenericObject) => void
    },
    clickStreamConfig?: {
        clickStreamTransporter: (clickStreamPayload: GenericObject) => void
    }
}) {
    useEffect(() => {
        if(adapterOptions) {
            adapter = new AdapterClass(adapterOptions);
        }
    }, [adapterOptions]);
    // @ts-expect-error sdfsf
   const [callState] = useReducer<any>(reducer, initialState,()=> initialState);

   function registerOnCallIncoming(callback : (callState: GenericObject)=>void) {
        //dispatch({type: actionTypes.CALL_INCOMING, payload: {}})
        adapter?.registerOnCallIncoming(callback);
    }

    function registerOnCallConnected(callback : (callState: GenericObject)=>void) {
        adapter?.registerOnCallConnected(callback);
    }

    function registerOnCallDisconnected(callback : (callState: GenericObject)=>void) {
        adapter?.registerOnCallDisconnected(callback);
    }

    function registerOnAdapterReady(callback : ()=> void) {
        adapter?.registerOnAdapterReady(callback);
    }


    function registerOnAgentAvailabilityChange(callback : (isAgentAvailable: boolean, reason: string) => void) {
        adapter?.registerOnAgentAvailabilityChange(callback);
    }

    function registerOnForcedLogoutListener(callback:()=>void) {
        adapter?.registerOnForcedLogoutListener(callback);
    }

    function  registerOnCallTransferStatus(callback: (data: GenericObject) => void) {
        adapter?.registerOnCallTransferStatus(callback);
    }

    function registerOnLoginFailedListener(callback:()=>void) {
       adapter?.registerOnLoginFailedListener(callback);
    }

    function acceptCall() {
        adapter?.acceptCall();
    }

    function rejectCall() {
        adapter?.rejectCall();
    }

    function disposeCall() {
        adapter?.disposeCall();
    }

    function muteCall() {
        adapter?.muteCall();
    }

    function unmuteCall() {
        adapter?.unmuteCall();
    }

    function logOut() {
       adapter?.logOut();
    }

    function initialize() {
         let metricProcessor;
         let clickStreamProcessor;
        if(metricsConfig && metricsConfig?.isMetricEnabled) {
             metricProcessor = new MetricsProcessor(metricsConfig?.metricUrl || '', metricsConfig?.metricFlowName || '', metricsConfig?.metricTransporter || noop);

        }
        if(clickStreamConfig?.clickStreamTransporter) {
            clickStreamProcessor = new ClickStreamProcessor(clickStreamConfig?.clickStreamTransporter || noop);
        }
        adapter?.init(metricProcessor, clickStreamProcessor);
    }

    function setOnBreak() {
        adapter?.setOnBreak();
    }

    function setAvailable() {
        adapter?.setAvailable();
    }

    function getAgentAvailability(): boolean {
        console.log('printing adapter', adapter);
        return adapter.getAgentAvailability();
    }

    function getLatestCallState(): CALL_STATES {
        return adapter.getLatestCallState();
    }

    function getAvailableAgentsForCallTransfer(): Promise<Agent[]> {
        return adapter.getAvailableAgentsForCallTransfer();
    }

    function transferCallToAgent(data: GenericObject) {
        adapter.transferCallToAgent(data);
    }

    return {
        callState,
        registerOnCallIncoming,
        registerOnCallConnected,
        registerOnCallDisconnected,
        registerOnAgentAvailabilityChange,
        registerOnForcedLogoutListener,
        registerOnCallTransferStatus,
        registerOnLoginFailedListener,
        acceptCall,
        rejectCall,
        disposeCall,
        muteCall,
        unmuteCall,
        initialize,
        logOut,
        setAvailable,
        getLatestCallState,
        setOnBreak,
        registerOnAdapterReady,
        getAgentAvailability,
        getAvailableAgentsForCallTransfer,
        transferCallToAgent
    }
}

export default UseCallSdk;