import {
  createAgoraRtcEngine,
  ClientRoleType,
  VideoSourceType,
  VideoViewSetupMode,
  ScreenCaptureSourceType,
  RenderModeType,
  ChannelProfileType
} from "agora-electron-sdk";
import { GetRoomRtcToken } from "@/api/Home/Index";
import { storage } from '@/utils';
const option: any = {
  appId: 'dcfc466a6ecb4a1f972630065dfb1e75',
  token: '',
  channelId: '',
  uid: ''
}
let rtcEngine: any = '';

const agora = {
  // 初始化
  init: async (bool: boolean = false) => {
    rtcEngine = createAgoraRtcEngine();
    await rtcEngine.initialize({
      appId: option.appId,
    });
    await agora.setDeviceManager(bool)
  },
  // 获取当前设备是否存在不存在就获取默认设备
  setDeviceManager: async (bool: boolean = false) => {
    const setting = await JSON.parse(storage.getItem('setting') as string)
    // 摄像头
    if (setting.videoDeviceId) {
      await agora.getVideoDeviceManager().then(async (res) => {
        let item = res.list.find((item: any) => item.deviceId === setting.videoDeviceId);
        if (item) {
          await agora.setVideoDeviceManager(setting.videoDeviceId)
        } else {
          await agora.setVideoDeviceManager(await rtcEngine.getVideoDeviceManager().getDevice())
          setting.videoDeviceId = await rtcEngine.getVideoDeviceManager().getDevice()
        }
      })
    } else {
      await agora.setVideoDeviceManager(await rtcEngine.getVideoDeviceManager().getDevice())
      setting.videoDeviceId = await rtcEngine.getVideoDeviceManager().getDevice()
    }

    // 播放设备
    if (setting.playBackDeviceId) {
      await agora.getAudioMediaList().then(async (res) => {
        let item = res.playBackList.find((item: any) => item.deviceId === setting.playBackDeviceId);
        if (item) {
          await agora.setPlaybackDevice(setting.playBackDeviceId)
        } else {
          await agora.setPlaybackDevice(res.playBackItem.deviceId)
          setting.playBackDeviceId = res.playBackItem.deviceId
        }
      })
    } else {
      let deviceId = await rtcEngine.getAudioDeviceManager().getPlaybackDefaultDevice().deviceId;
      await agora.setPlaybackDevice(deviceId)
      setting.playBackDeviceId = deviceId
    }

    // 音频设备
    if (setting.ecordingDeviceId) {
      await agora.getAudioMediaList().then(async (res) => {
        let item = res.ecordingList.find((item: any) => item.deviceId === setting.ecordingDeviceId);
        if (item) {
          await agora.setRecordingDevice(setting.ecordingDeviceId)
        } else {
          await agora.setRecordingDevice(res.ecordingItem.deviceId)
          setting.ecordingDeviceId = res.ecordingItem.deviceId
        }
      })
    } else {
      let deviceId = await rtcEngine.getAudioDeviceManager().getRecordingDefaultDevice().deviceId;
      await agora.setRecordingDevice(deviceId)
      setting.ecordingDeviceId = deviceId
    }
    setTimeout(async () => {
      storage.setItem('setting', JSON.stringify(setting))
      if (bool) {
        const setting = await JSON.parse(storage.getItem('setting') as string)
        if (setting.videoDeviceId) agora.setVideoDeviceManager(setting.videoDeviceId) //指定摄像头头采集设备
        if (setting.playBackDeviceId) agora.setPlaybackDevice(setting.playBackDeviceId) //指定播放设备
        if (setting.playBackVolume) agora.setPlaybackDeviceVolume(setting.playBackVolume) // 设置播放设备音量
        if (setting.ecordingDeviceId) agora.setRecordingDevice(setting.ecordingDeviceId) // 设置音频采集设备
        if (setting.ecordingVolume) agora.setRecordingDeviceVolume(setting.ecordingVolume) // 设置音频设备音量
        rtcEngine.enableAudioVolumeIndication(100, 1, true)
      }
    }, 1000);
  },
  // 事件回调
  registerEventHandler: ({ onJoinChannelSuccess, onUserJoined, onUserOffline, onAudioVolumeIndication }: any) => {
    rtcEngine.registerEventHandler({
      // 监听本地用户加入频道事件
      onJoinChannelSuccess: async (info: any, elapsed: any) => {
        await onJoinChannelSuccess(info, elapsed)
      },
      // 监听远端用户加入频道事件
      onUserJoined: async (info: any, remoteUid: any, elapsed: any) => {
        await onUserJoined(info, remoteUid, elapsed)
      },
      // 监听用户离开频道事件
      onUserOffline: async (info: any, remoteUid: any, reason: any) => {
        await onUserOffline(info, remoteUid, reason)
      },
      // // 视频发布状态改变回调
      // onVideoPublishStateChanged: (source: any, channel: any, oldState: any, newState: any, elapseSinceLastState: any) => {
      //   if (newState === 1) {

      //   }
      // },
      // // 音频发布状态改变回调
      // onAudioPublishStateChanged: (channel: any, oldState: any, newState: any, elapseSinceLastState: any) => {
      //   if (newState === 1) {

      //   }
      // },
      // // 用户音量提示回调。
      onAudioVolumeIndication: async (_connection: any, speakers: any, _speakerNumber: any, _totalVolume: any,) => {
        await onAudioVolumeIndication(speakers)
      }
    });
  },
  // 获取视图模式
  getRrenderMode: (uid: number) => {
    if (String(uid).length === 9) {
      return RenderModeType.RenderModeFit
    } else {
      return RenderModeType.RenderModeHidden
    }
  },
  // 本地加入
  setupLocalVideo: async (item: any) => {
    if (item.view?.childNodes.length === 1) {
      await rtcEngine.setupLocalVideo({
        renderMode: agora.getRrenderMode(item.uid),
        sourceType: item.sourceType,
        uid: item.uid,
        view: item.view,
        setupMode: VideoViewSetupMode.VideoViewSetupAdd,
      });
    }
  },
  // 远端加入
  setupRemoteVideoJoin: async (item: any) => {
    if (item.view?.childNodes.length === 1) {
      await rtcEngine.setupRemoteVideo(
        {
          renderMode: agora.getRrenderMode(item.uid),
          sourceType: VideoSourceType.VideoSourceRemote,
          uid: item.uid,
          view: item.view,
          setupMode: VideoViewSetupMode.VideoViewSetupAdd,
        },
        { channelId: item.channelId },
      );
    }
  },
  // 退出
  setupRemoteVideo: async (item: any) => {
    await rtcEngine.setupRemoteVideo(
      {
        renderMode: agora.getRrenderMode(item.uid),
        sourceType: VideoSourceType.VideoSourceRemote,
        uid: item.uid,
        view: item.view,
        setupMode: VideoViewSetupMode.VideoViewSetupRemove,
      },
    );
  },
  // 销毁
  release: async () => {
    await rtcEngine.release()
  },
  // 离开频道
  leaveChannel: async () => {
    await rtcEngine.leaveChannel({
      stopAudioMixing: true,
      stopAllEffect: true,
      stopMicrophoneRecording: true,
    })
    agora.stopScreenCapture()
    agora.release()
  },
  // 加入频道
  joinChannel: () => {
    rtcEngine.joinChannel(option.token, option.channelId, option.uid, {
      autoSubscribeAudio: true,//设置是否自动订阅所有音频流
      autoSubscribeVideo: true,//设置是否自动订阅所有视频流
      publishMicrophoneTrack: true,//设置是否发布麦克风采集到的音频
      publishCameraTrack: true,//设置是否发布摄像头采集的视频
      clientRoleType: ClientRoleType.ClientRoleBroadcaster, //用户角色  ClientRoleBroadcaster 主播  ClientRoleAudience 观众
      publishScreenTrack: false,//设置是否发布屏幕采集的视频
    });
  },
  // 共享屏幕单独用户
  joinChannelEx: async (uid: any) => {
    await agora.leaveChannelEx(uid)
    await rtcEngine.joinChannelEx(
      option.token,
      { channelId: option.channelId, localUid: Number(uid) },
      {
        autoSubscribeAudio: false,//设置是否自动订阅所有音频流
        autoSubscribeVideo: false,//设置是否自动订阅所有视频流
        publishMicrophoneTrack: false,//设置是否发布麦克风采集到的音频
        publishCameraTrack: false,//设置是否发布摄像头采集的视频
        clientRoleType: ClientRoleType.ClientRoleBroadcaster,//用户角色  ClientRoleBroadcaster 主播  ClientRoleAudience 观众
        publishScreenTrack: true,//设置是否发布屏幕采集的视频
      }
    );
  },
  // 离开共享屏幕频道
  leaveChannelEx: async (uid: any) => {
    await rtcEngine.leaveChannelEx({ channelId: option.channelId, localUid: Number(uid) })
  },
  // 停止共享屏幕
  stopScreenCapture: () => {
    rtcEngine.stopScreenCapture();
    rtcEngine.enableLoopbackRecording(false)
  },
  // 取消或恢复发布本地音频流
  muteLocalAudioStream: (mute: any) => {
    rtcEngine.muteLocalAudioStream(mute)
  },
  // 取消或恢复发布本地视频流
  muteLocalVideoStream: (mute: any) => {
    rtcEngine.muteLocalVideoStream(mute)
  },
  // 摄像头采集
  startCameraCapture: async () => {
    await rtcEngine.startCameraCapture(VideoSourceType.VideoSourceCamera, {})
  },
  // 停止采集摄像头
  stopCameraCapture: async () => {
    await rtcEngine.stopCameraCapture()
  },
  // 加入频道
  setJoinChannel: async (data: any) => {
    option.token = data.token;
    option.channelId = data.channelId;
    option.uid = Number(data.uid);
    agora.joinChannel()
  },
  // 桌面捕获音频和视频的媒体源的信息
  getDesktopCapturerVideo: async () => {
    return rtcEngine.getScreenCaptureSources({ width: 300, height: 300 }, { width: 300, height: 300 }, true);
  },
  // 共享屏幕采集
  setDesktopCapturerVideo: async (targetSource: any, isComputerAudio: boolean, isFluencyPriority: boolean) => {
    const user = JSON.parse(storage.getItem('user') as string)
    agora.stopScreenCapture();
    if (isComputerAudio) {
      rtcEngine.enableLoopbackRecording(true)
    }
    let data = {};
    if (isFluencyPriority) {
      data = {
        frameRate: 15,
        dimensions: {
          window: 3000,
          height: 3000,
        }
      }
    }
    if (
      targetSource.type ===
      ScreenCaptureSourceType.ScreencapturesourcetypeScreen
    ) {
      rtcEngine.startScreenCaptureByDisplayId(
        targetSource.sourceId,
        {},
        {
          windowFocus: true,
          enableHighLight: true,
          highLightColor: 0xFF99CC00,
          ...data
        }
      );
    } else {
      rtcEngine.startScreenCaptureByWindowId(
        targetSource.sourceId,
        {},
        {
          windowFocus: true,
          enableHighLight: true,
          highLightColor: 0xFF99CC00,
          ...data
        }
      );
    }
    await agora.joinChannelEx(user.screenShareId)
  },
  // 获取系统中所有的视频设备列表。
  getVideoDeviceManager: async (): Promise<any> => {
    return {
      list: rtcEngine.getVideoDeviceManager().enumerateVideoDevices(),
      item: rtcEngine.getVideoDeviceManager().getDevice()
    }
  },
  // 通过设备 ID 指定视频采集设备。
  setVideoDeviceManager: async (deviceIdUTF8: string) => {
    await rtcEngine.getVideoDeviceManager().setDevice(deviceIdUTF8)
  },
  // 开启本地视频预览
  startPreview: async (id: string, uid: number): Promise<void> => {
    rtcEngine.enableVideo();
    rtcEngine.startPreview();
    await GetRoomRtcToken(`${+new Date()}`).then(async (res) => {
      await rtcEngine.joinChannelEx(res.data, {
        channelId: `${+new Date() + uid}`,
        localUid: uid,
      }, {
        channelProfile: ChannelProfileType.ChannelProfileLiveBroadcasting,
        clientRoleType: ClientRoleType.ClientRoleBroadcaster,
        publishMicrophoneTrack: true,
        publishCameraTrack: true,
        autoSubscribeAudio: true,
        autoSubscribeVideo: true,
      });
      rtcEngine.setupLocalVideo({
        sourceType: VideoSourceType.VideoSourceCameraPrimary,
        uid,
        view: document.getElementById(id),
        setupMode: VideoViewSetupMode.VideoViewSetupAdd,
      });
    })
  },
  // 获取输入输出设备列表
  getAudioMediaList: async () => {
    return {
      playBackList: rtcEngine.getAudioDeviceManager().enumeratePlaybackDevices(),
      ecordingList: rtcEngine.getAudioDeviceManager().enumerateRecordingDevices(),
      playBackItem: rtcEngine.getAudioDeviceManager().getPlaybackDefaultDevice(),
      ecordingItem: rtcEngine.getAudioDeviceManager().getRecordingDefaultDevice(),
      ecordingVolume: rtcEngine.getAudioDeviceManager().getRecordingDeviceVolume(),
    }
  },
  // 启动音频播放设备测试。
  startPlaybackDeviceTest: async () => {
    await rtcEngine.getAudioDeviceManager().startPlaybackDeviceTest('https://wgshare.oss-cn-chengdu.aliyuncs.com/TestAudio.mp3')
  },
  // 	停止音频播放设备测试。
  stopPlaybackDeviceTest: async () => {
    await rtcEngine.getAudioDeviceManager().stopPlaybackDeviceTest()
  },
  // 设置播放设备音量
  setPlaybackDeviceVolume: async (volume: number) => {
    await rtcEngine.getAudioDeviceManager().setPlaybackDeviceVolume(volume)
  },
  // 指定播放设备
  setPlaybackDevice: async (deviceId: string) => {
    await rtcEngine.getAudioDeviceManager().setPlaybackDevice(deviceId)
  },
  // 启动音频采集设备测试
  startRecordingDeviceTest: async (indicationInterval: number) => {
    await rtcEngine.getAudioDeviceManager().startRecordingDeviceTest(indicationInterval)
  },
  // 设置音频设备音量
  setRecordingDeviceVolume: async (volume: number) => {
    await rtcEngine.getAudioDeviceManager().setRecordingDeviceVolume(volume)
  },
  // 设置音频采集设备
  setRecordingDevice: async (deviceId: string) => {
    await rtcEngine.getAudioDeviceManager().setRecordingDevice(deviceId)
  },
  // 停止音频采集设备测试
  stopRecordingDeviceTest: async () => {
    await rtcEngine.getAudioDeviceManager().stopRecordingDeviceTest()
  },

}

export default agora;