// import {  Notification } from '@arco-design/web-vue';
import { ElNotification, ElMessage } from 'element-plus'
import emitter from "@/utils/eventBus.js";
// import handleCallingNotification from '../hooks/callingNotification';

let call_id;
let hangup_event_cb_id;
let force_hangup_event_cb_id;
let answer_ack_cb_id;
let incoming_cb_id;
let floor_grant_cb_id;

// Whether it is a pushVideoFile call
// 是否为视频推送的呼叫
let pushing_video = false;
// monitor call list
// 值守呼叫列表
const monitor_call_list = [];

export default function useCallModule() {
  // we allow only one call exist in demo.but actually,sdk supports more

  /**
   * make private vioce call,return nothing,receive result in callback
   * This interface has been expanded to support  makeGroupVoiceCall、makeDispatcherVoiceCall、makeConferenceVoiceCall、makeCrosspatchVoiceCall
   * 这个接口已扩展，除了支持语音单呼外，还支持语音组呼、语音呼叫调度员、语音会议、群组呼叫。
   * @param record who you wanna call
   * @returns
   */
  const makeVoiceCall = (record) => {
    if (call_id) {
      console.warn('we allow only one call exist,please hangup first');
      return;
    }

    window.lemon.call
      .makeVoiceCall({ basedata_id: record.basedata_id, hook_flag: 0 })
      ?.then((resp) => {
        call_id = resp.call_id;
        console.info('makeVoiceCall succ,registerCallEstablishEvent', call_id);
      });

    // test
    // window.lemon.call.changeCamera({ call_id, target_camera: 0 });

    // also can use  this makecall method,the method provides the most comprehensive call capability
    // For example, Voice private call, ensure that the basedata_id is a private
    // window.lemon.call
    //   .makeCall({
    //     callee_guid: record.basedata_id,
    //     attribute: {
    //       call_type: 0,
    //       call_mode: 0,
    //       duplex_flag: 0,
    //     },
    //   })
    //   ?.then((resp) => {
    //     console.info('makeCall succ,resp', resp);
    //     call_id = resp.call_id;
    //   });

    // For example, Voice group call,ensure that the basedata_id is a group
    // window.lemon.call
    //   .makeCall({
    //     callee_guid: record.basedata_id,
    //     attribute: {
    //       call_type: 1,
    //       call_mode: 0,
    //       duplex_flag: 0, // group call  ,the value must be 0
    //     },
    //   })
    //   ?.then((resp) => {
    //     console.info('makeCall succ,resp', resp);
    //     call_id = resp.call_id;
    //   });
  };
  /**
   * make private video call,call with vioce and video,return nothing,receive result in callback
   * This interface has been expanded to support makeGroupVideoCall、makeDispatcherVideoCall、makeConferenceVideoCall
   * 这个接口已扩展，除了支持视频单呼外，还支持视频组呼、视频呼叫调度员、视频会议
   * @param record who you wanna call
   * @returns
   */
  const makeVideoCall = (record) => {
    if (call_id) {
      console.warn('we allow only one call exist,please hangup first');
      return;
    }
    window.lemon.call
      .makeVideoCall({ basedata_id: record.basedata_id, video_frame_size: 3 })
      ?.then((resp) => {
        call_id = resp.call_id;

        console.warn('makeVideoCall succ,call_id=', call_id);
      });

    // also can use  this makecall method,the method provides the most comprehensive call capability
    // For example, Video private call (with voice), ensure that the basedata_id is a private
    // window.lemon.call
    //   .makeCall({
    //     callee_guid: record.basedata_id,
    //     attribute: {
    //       call_type: 11,
    //       call_mode: 2,
    //       duplex_flag: 1,
    //     },
    //     video_frame_size: window.lemon.call.getMaxFrameSize(),
    //   })
    //   ?.then((resp) => {
    //     console.info('makeCall succ,resp', resp);
    //     call_id = resp.call_id;
    //   });

    // For example, Video group call,ensure that the basedata_id is a group
    // window.lemon.call
    //   .makeCall({
    //     callee_guid: record.basedata_id,
    //     attribute: {
    //       call_type: 13,
    //       call_mode: 2,
    //       duplex_flag: 0, // group call  ,the value must be 0
    //     },
    //     video_frame_size: window.lemon.call.getMaxFrameSize(),
    //   })
    //   ?.then((resp) => {
    //     console.info('makeCall succ,resp', resp);
    //     call_id = resp.call_id;
    //   });
  };
  const makeGroupVideoCall = (record) => {
    if (call_id) {
      console.warn('we allow only one call exist,please hangup first');
      return;
    }
    window.lemon.call
      .makeGroupVideoCall({
        basedata_id: record.basedata_id,
        video_frame_size: 3,
      })
      ?.then((resp) => {
        console.log('makeGroupVideoCall call_id = ', call_id);
        call_id = resp.call_id;
      });
  };
  const makeGroupVoiceCall = (record) => {
    if (call_id) {
      console.warn('we allow only one call exist,please hangup first');
      return;
    }
    window.lemon.call
      .makeGroupVoiceCall({
        basedata_id: record.basedata_id,
      })
      ?.then((resp) => {
        call_id = resp.call_id;
      });
  };

  const makeCrosspatchVoiceCall = (record) => {
    window.lemon.call
      .makeCrosspatchVoiceCall({ basedata_id: record.basedata_id })
      ?.then((resp) => {
        call_id = resp.call_id;
      });
  };

  /**
   * 视频上拉
   * make pure video call,only video, no voice
   * @param record who you wanna call
   * @returns
   */
  const pureVideoCall = (record) => {
    if (call_id) {
      console.warn('we allow only one call exist,please hangup first');
      return;
    }
    window.lemon.call
      .pullVideo({ basedata_id: record.basedata_id, hook_flag: 0 })
      ?.then((resp) => {
        call_id = resp.call_id;
      });
  };
  /**
   * 环境监听
   * @param record
   */
  const voiceDetect = (record) => {
    window.lemon.call
      .makeCall({
        callee_guid: record.basedata_id,
        attribute: {
          call_type: 0,
          call_mode: 0,
          duplex_flag: 0,
          ambience_flag: 1,
        },
      })
      ?.then((resp) => {
        call_id = resp.call_id;
      });
  };

  /**
   * 环境监视
   * @param record
   */
  const videoDetect = (record) => {
    window.lemon.call
      .makeCall({
        callee_guid: record.basedata_id,
        attribute: {
          call_type: 11,
          call_mode: 2,
          duplex_flag: 0,
          ambience_flag: 1,
        },
      })
      ?.then((resp) => {
        call_id = resp.call_id;
      });
  };
  /**
   * 音频会议
   * @param record
   */
  const makeConferenceVoiceCall = (record) => {
    window.lemon.call
      .makeConferenceVoiceCall({
        basedata_id: record.basedata_id,
      })
      ?.then((resp) => {
        call_id = resp.call_id;
      });
  };
  /**
   * 音视频会议
   * @param record
   */
  const makeConferenceVideoCall = (record) => {
    window.lemon.call
      .makeConferenceVideoCall({
        basedata_id: record.basedata_id,
      })
      ?.then((resp) => {
        call_id = resp.call_id;
      });
  };

  // 广播呼叫
  // Broadcast Call
  const makeBroadcastCall = (record) => {
    window.lemon.call
      .makeCall({
        callee_guid: record.basedata_id,
        attribute: {
          call_type: 3,
          call_mode: 0,
        },
      })
      ?.then((resp) => {
        call_id = resp.call_id;
      });
  };

  /**
   * hangup call
   */
  const hangup = (id) => {
    console.info('try hangup,call_id=', call_id);
    console.info('try hangup,id=', id);

    window.lemon.call
      .hangupCall({ call_id: id || call_id })
      ?.then(() => {
        call_id = undefined;
        window.calling_conference = undefined;
        // console.log('22222registerCallEstablishEven');
      })
      .catch((err) => {
        console.error('hangup call error,', err);
      });
  };

  /**
   *  接听呼叫
   * answer call
   */
  const answerCall = () => {
    ElNotification.close(call_id);

    window.lemon.call
      .answerCall({ call_id })
      ?.then(() => {
        // display alert ui
        ElNotification.close(call_id);
      })
      .catch((err) => {
        console.error('answer call error,', err);
      });
  };

  // 禁麦
  // mute the microphone
  const setMuteMic = (mute) => {
    return window.lemon.call.muteMic({
      call_id,
      is_mute: mute,
    });
  };

  // 禁摄像头
  //  disable the camera
  const setMuteCamera = (mute) => {
    return window.lemon.call.muteCamera({
      call_id,
      is_mute: mute,
    });
  };
  //  静音
  //  mute call
  const setMuteCall = (mute) => {
    return window.lemon.call.muteCall({
      call_id,
      is_mute: mute,
    });
  };

  const removeMonitorCall = (callId) => {
    const index = monitor_call_list.findIndex(
      (item) => item.call_id === callId
    );
    if (index >= 0) {
      monitor_call_list.splice(index, 1);
      emitter.emit('monitorUpdate');
    }
  };

  const getMonitorCallList = () => {
    return monitor_call_list;
  };

  // 添加 挂断 回调
  // After hanging up the call, you can receive a notification and process the style of the current page based on the notification
  const registerhangupEvent = () => {
    if (hangup_event_cb_id !== undefined) {
      return;
    }

    hangup_event_cb_id = window.lemon.call.addHangupEvt((data) => {
      console.info('receive hangup event');
      console.info(
        'receive hangup event receive call id',
        String(data.call_id)
      );
      console.info('receive hangup event local call id', String(call_id));
      if (data.call_id === call_id) {
        // remove display alert ui
        ElNotification.close(call_id);
        call_id = undefined;
        window.calling_conference = undefined;
        // console.log('2222211111registerCallEstablishEvent');
      }

      // pushVideoFile uninit
      // 如果是视频推送的，挂断是反初始化一些东西。
      if (pushing_video) {
        window.video.src = undefined;
        window.showVideo.value = false;
        pushing_video = false;
        window.videoViewRoot.style.display = 'none';
      }
      removeMonitorCall(data.call_id);
    });
  };

  // 添加强拆事件
  const registerForceHangupEvent = () => {
    if (force_hangup_event_cb_id !== undefined) {
      return;
    }
    force_hangup_event_cb_id = window.lemon.call.addForceHangupEvt((data) => {
      // 目前强拆成功，都是走挂断通知事件。  当失败了，才走强拆事件通知。
      if (data.result === 0) {
        if (data.call_id === call_id) {
          ElNotification.close(call_id);
          call_id = undefined;
          window.calling_conference = undefined;
        }
        removeMonitorCall(data.call_id);
      } else {
        // 强拆失败   fail
        ElMessage.error("强拆失败");
      }
    });
  };

  // 添加接听回调通知 代表呼叫建立
  // receive the answer acknowledgement asynchronously after the call is established
  const registerCallEstablishEvent = () => {
    if (answer_ack_cb_id !== undefined) {
      return;
    }
    answer_ack_cb_id = window.lemon.call.addAnswerAckEvt((data) => {
      // console.info('registerCallEstablishEvent0', call_id);
      console.info('registerCallEstablishEvent', String(data.call_id));
      console.info('registerCallEstablishEvent', JSON.stringify(data));

      call_id = data.call_id;
      //  pushVideoFile init
      // 接通后，视频推送的文件开始播放
      if (pushing_video) {
        window.videoViewRoot.style.display = 'unset';
        window.showVideo.value = true;
        window.video.play();
      }
    });
  };

  // 注册来电通知回调
  // add the incoming call callback
  const registerReceiveCallEvent = () => {
    if (incoming_cb_id !== undefined) {
      return;
    }
    incoming_cb_id = window.lemon.call.addIncomingEvt((session) => {
      console.log('receive call------>', session);
      call_id = session.call_id;
      const callingReq = {
        callInfo: session,
        equipment: undefined,
        text: {
          calling: '队列',
          answer: '接听',
          hangUp: '挂断',
        },
      };
      console.log('receive this------>', useCallModule());
      if (session.listen_flag) {
        // monitor call,auto answer call
        // 值守的来电呼叫,自动接听
        window.lemon.call.answerCall({ call_id: session.call_id });
        monitor_call_list.push(session);

        emitter.emit('monitorUpdate');
      } else {
        // normal call
        // 正常来电，弹框询问接听
        // handleCallingNotification(callingReq);
      }
    });
  };

  // 申请话权
  // apply floor
  const applyFloor = () => {
    console.info('try applyFloor,call_id=', call_id);
    if (!call_id) {
      console.warn('no call exits');
      return undefined;
    }
    return window.lemon.floor
      .applySpeak({ call_id })
      ?.then((resp) => {
        if (resp.result === 0) {
          console.log('applyFloor request sucess');
        } else {
          ElMessage.error("申请话权失败");
        }
      })
      .catch((err) => {
        console.error('applyFloor error,', err);
      });
  };

  // 释放话权
  // release floor
  const releaseFloor = () => {
    console.info('try releaseFloor,call_id=', call_id);
    return window.lemon.floor
      .releaseSpeak({ call_id })
      ?.then((resp) => {
        if (resp.result === 0) {
          console.log('releaseSpeak request sucess');
        } else {
          ElMessage.error("释放话权失败");
        }
      })
      .catch((err) => {
        console.error('releaseSpeak error,', err);
      });
  };

  // add floor event
  // 添加话权通知事件
  const registerFloorGrantEvent = () => {
    if (floor_grant_cb_id !== undefined) {
      return;
    }
    floor_grant_cb_id = window.lemon.floor.addGrantEvt((grantInfo) => {
      console.log('registerFloorGrantEvent', grantInfo);
      if (grantInfo.result !== 0) {
        ElMessage.error("话权申请失败");
      }
    });
  };

  //  强拆
  //  override the call
  const forceHangupCall = (callId) => {
    return window.lemon.call
      .forceHangupCall({ call_id: callId || call_id })
      ?.then((resp) => {
        if (resp.result === 0) {
          console.log('forceHangupCall request sucess');
        } else {
          ElMessage.error("强拆失败");
        }
        call_id = undefined;
        window.calling_conference = undefined;
        // console.log('2222233registerCallEstablishEven');
      })
      .catch((err) => {
        console.error('forceHangupCall error,', err);
      });
  };
  //  强插
  //  interrupt the call during monitoring
  const forceApplySpeak = (callId) => {
    return window.lemon.floor
      .forceApplySpeak({ call_id: callId || call_id })
      ?.then((resp) => {
        if (resp.result === 0) {
          console.log('forceApplySpeak request sucess');
          call_id = callId;
        } else {
          ElMessage.error("强插失败");
        }
      })
      .catch((err) => {
        console.error('forceApplySpeak error,', err);
      });
  };

  /**
   * 会议成员禁言
   * mute or unmute a conference member
   * @param param
   *  @param param.conference_basedata_id
   */
  const muteMemberInConference = (
    conference_basedata_id,
    member_basedata_id,
    mute
  ) => {
    return window.lemon.call.conferenceMemberSpeakSet({
      conference_call_id: call_id,
      conference_basedata_id,
      member_setting: {
        member_basedata_id,
        forbid: mute ? 1 : 0,
      },
    });
  };

  /**
   * 视频推送
   * select a local video file and play then push the stream to remote
   * @param record
   * @param file
   * @returns
   */
  const pushVideoFile = (record, url) => {
    console.info('try pushVideoFile,call_id=', call_id);
    if (call_id) {
      console.warn('call exits');
      return;
    }
    console.warn('window.video', window.video);
    // set the file to video tag
    if (window.video) {
      const canPlayListener = () => {
        window.video.removeEventListener('canplay', canPlayListener);
        // capture stream
        const stream = (window.video)?.captureStream();
        console.info('pushVideoFile,inited stream=', stream);
        // register hook listner ,play the video when remote hooked
        registerCallEstablishEvent();
        // init the call
        window.lemon.call
          .pushVideoFile({
            basedata_id: record?.basedata_id,
            stream,
          })
          ?.then((resp) => {
            pushing_video = true;
            call_id = resp.call_id;
          });
      };

      const endListener = () => {
        console.info('pushVideoFile,video play end');
        window.video.removeEventListener('ended', endListener);
        hangup();
      };
      // maybe did't finish the video,so that we has listener already,remove it
      window.video.removeEventListener('ended', endListener);
      console.info('pushVideoFile,add canplay Event Listener', canPlayListener);
      window.video.addEventListener('canplay', canPlayListener);
      // hangup the call when video finished
      console.info('pushVideoFile,add ended Event Listener', endListener);
      window.video.addEventListener('ended', endListener);
      window.video.autoplay = false;
      window.video.src = url;
    }
  };

  /**
   * 视频转发
   * share a exist call to another device
   * @param record
   * @param stop
   * @returns
   */
  const forwardVideoCall = (record, stop) => {
    console.info('try forwardVideoCall,call_id=', call_id);
    if (!call_id) {
      console.warn('no call exits,can not forward');
      ElMessage.warning('no call exits');
      return undefined;
    }
    return window.lemon.call
      .forwardVideoCall({
        basedata_id: record?.basedata_id,
        call_id,
        action: stop ? 1 : 0,
      })
      ?.then((resp) => {
        if (resp.result === 0) {
          console.log('forwardVideoCall request sucess');
        } else {
          ElMessage.error("视频转发失败");
        }
      })
      .catch((err) => {
        console.error('forwardVideoCall error,', err);
      });
  };

  const getEmitter = () => {
    return emitter;
  };

  // call sdk unInit
  const unInit = () => {
    call_id = undefined;

    if (hangup_event_cb_id) {
      window.lemon.call.removeHangupEvt(hangup_event_cb_id);
      hangup_event_cb_id = undefined;
    }
    if (force_hangup_event_cb_id) {
      window.lemon.call.removeForceHangupEvt(force_hangup_event_cb_id);
      force_hangup_event_cb_id = undefined;
    }
    if (answer_ack_cb_id) {
      window.lemon.call.removeAnswerAckEvt(answer_ack_cb_id);
      answer_ack_cb_id = undefined;
    }
    if (incoming_cb_id) {
      window.lemon.call.removeIncomingEvt(incoming_cb_id);
      incoming_cb_id = undefined;
    }
    if (floor_grant_cb_id) {
      window.lemon.floor.removeGrantEvt(floor_grant_cb_id);
      floor_grant_cb_id = undefined;
    }
    monitor_call_list.length = 0;
  };

  return {
    makeVoiceCall,
    makeVideoCall,
    pureVideoCall,
    registerhangupEvent,
    registerReceiveCallEvent,
    answerCall,
    makeGroupVoiceCall,
    makeGroupVideoCall,
    makeBroadcastCall,
    hangup,
    voiceDetect,
    videoDetect,
    applyFloor,
    releaseFloor,
    setMuteCamera,
    setMuteMic,
    setMuteCall,
    muteMemberInConference,
    makeConferenceVoiceCall,
    makeConferenceVideoCall,
    makeCrosspatchVoiceCall,
    registerCallEstablishEvent,
    pushVideoFile,
    forwardVideoCall,
    forceHangupCall,
    getMonitorCallList,
    getEmitter,
    forceApplySpeak,
    registerFloorGrantEvent,
    registerForceHangupEvent,
    unInit,
  };
}