import { PayloadAction, createSlice } from '@reduxjs/toolkit';
import { Logger } from '../../utils/Log';
import { IPbxCall, IPbxState, ITelephonyCapabilities, } from './types';
import { } from '../../services/invitations-service';
import { pbxService } from '../../services/calls/pbx';
import { currentCallService } from '../../services/calls';
import { Platform } from 'react-native';
import { PERMISSIONS, RESULTS } from 'react-native-permissions';
import { permissionsService } from '../../services/Permissions';
import { Strings } from '../../resources/localization/Strings';

const logger = new Logger('invitationsSlice');

const initialState: IPbxState = {
    pbxCall: undefined,
    forwardStatus: '',
    forwardPhoneNumber: '',
    isTelephonyEnabled: false,
    deviceNumber: '',
    isNomadicFeatureActivated: false,
    hasMediaPillar: false,
    isVoipEnabled: false,
    isNomadicEnabled: false,
    secondCall: undefined,
    sessionsCount: 0,
    forwardOptions: [],
    nomadicNumber: '',
    calledPhoneNumber: ''
}

const pbxSlice = createSlice({
    name: 'pbx',
    initialState,
    reducers: {
        callPBX(state, action:PayloadAction<string>){
            state.calledPhoneNumber = action.payload;
            const microphonePermission =
      Platform.OS === 'ios'
        ? PERMISSIONS.IOS.MICROPHONE
        : PERMISSIONS.ANDROID.RECORD_AUDIO;
    permissionsService.checkPermission(microphonePermission).then((result) => {
      if (result === RESULTS.GRANTED) {
        pbxService.startCall(action.payload);
      } else {
        permissionsService.openSettingAlert(
          Strings.CallPermissionsTittle,
          Strings.CallPermissionsMsg
        );
      }
    });
        },
        setPBXCall(state, action: PayloadAction<IPbxCall | undefined>) {
            state.pbxCall = action.payload;
        },
        switchNomadic(state, action: PayloadAction<{ isNomadicEnabled: boolean, isVoipEnabled: boolean, nomadicType: string }>) {
            pbxService.switchNomadic(action.payload.isNomadicEnabled, action.payload.isVoipEnabled, action.payload.nomadicType);
        },
        holdCall(state, action: PayloadAction<string>) {
            pbxService.holdCall(action.payload);
        },
        retrieveCall(state, action: PayloadAction<string>) {
            pbxService.retrieveCall(action.payload);
        },
        forwardCallToVoiceMail(state, action: PayloadAction<string>) {
            pbxService.forwardCallToVoiceMail(action.payload);
        },
        redirectCallsToVoiceMail(state) {
            pbxService.redirectCallsToVoiceMail();
        },
        cancelCallForward(state) {
            pbxService.cancelCallForward();
        },
        forwardCallsToPhoneNumber(state, action: PayloadAction<string>) {
            pbxService.forwardCallsToPhoneNumber(action.payload);
        },
        forwardCallToPersonalMobile(state) {
            pbxService.forwardToPersonalMobile();
        },
        forwardToPersonalPhone(state) {
            pbxService.forwardToPersonalPhone();
        },
        updateCallForwardStatus(state, action: PayloadAction<string>) {
            state.forwardStatus = action.payload;
        },
        setTelephonyCapabilities(state, action: PayloadAction<ITelephonyCapabilities>) {
            state = {
                ...state,
                isNomadicEnabled: action.payload.isNomadicEnabled,
                isTelephonyEnabled: action.payload.isTelephonyEnabled,
                isNomadicFeatureActivated: action.payload.isNomadicFeatureActivated,
                deviceNumber: action.payload.deviceNumber,
                hasMediaPillar: action.payload.hasMediaPillar,
                isVoipEnabled: action.payload.isVoipEnabled
            }
        },
        unregisterForwardStatusChangeListener(state){
            pbxService.unregisterForwardStatusChangeListener();
        },
        unregisterNomadicStatusChangeListener(state){
            pbxService.unregisterNomadicStatusChangeListener();
        },
        getCurrentForwardStatus(state){
            pbxService.getCurrentForwardStatus();
        },
        getForwardAvailableOptions(state){
            pbxService.getForwardAvailableOptions();
        },
        setForwardPhoneNumber(state, action: PayloadAction<string>){
            state.forwardPhoneNumber = action.payload;
        },
        getForwardAvailableOptionsResult(state,action: PayloadAction<[]>){
            state.forwardOptions = action.payload;
        },
        setSecondCallUpdates(state, action: PayloadAction<IPbxCall | undefined>){
            state.secondCall = action.payload;
        },
        setSessionsCountUpdates(state, action: PayloadAction<number>){
            state.sessionsCount = action.payload;
        },
        endCall(state,action: PayloadAction<string>){
            pbxService.endCall(action.payload);
        },
        takeCall(state,action: PayloadAction<string>){
            pbxService.takeCall(action.payload);
        },
        rejectCall(state,){
            pbxService.rejectCall();
        },
        alternateCalls(state, action:PayloadAction<{  activeCallId: string,
            heldCallId: string}>){
                pbxService.alternateCalls(action.payload.activeCallId, action.payload.heldCallId);
        },
        getNomadicNumber(state){
            pbxService.getNomadicNumber();
        },
        setNomadicNumber(state, action:PayloadAction<string>){
            state.nomadicNumber = action.payload;
        },
        setMyMobileNumber(state, action:PayloadAction<string>){
            pbxService.setNomadicNumber(action.payload);
        },
        addNewCall(){
            currentCallService.hideActiveCallView();
        },
        makeConferenceCall(state, action:PayloadAction<{  activeCallId: string,
            heldCallId: string}>){
            pbxService.makeConferenceCall( action.payload.activeCallId,action.payload.heldCallId);
        },
        checkTelephonyCapabilities(){
            pbxService.checkTelephonyCapabilities()
        },

    }
});

// Export action creators and reducer
export const {
    setPBXCall,
    switchNomadic,
    holdCall,
    retrieveCall,
    redirectCallsToVoiceMail,
    cancelCallForward,
    forwardCallToVoiceMail,
    forwardCallsToPhoneNumber,
    forwardCallToPersonalMobile,
    forwardToPersonalPhone,
    updateCallForwardStatus,
    setTelephonyCapabilities,
    unregisterForwardStatusChangeListener,
    unregisterNomadicStatusChangeListener,
    getCurrentForwardStatus,
    getForwardAvailableOptions,
    setForwardPhoneNumber,
    getForwardAvailableOptionsResult,
    setSecondCallUpdates,
    setSessionsCountUpdates,
    endCall,
    takeCall,
    rejectCall,
    alternateCalls,
    getNomadicNumber,
    setNomadicNumber,
    setMyMobileNumber,
    addNewCall,
    makeConferenceCall,
    checkTelephonyCapabilities,
    callPBX    
} = pbxSlice.actions;

export default pbxSlice.reducer;