// TIM H5 环境适配器
import TIM from 'tim-js-sdk';
import TRTC from 'trtc-js-sdk';

// 初始化配置
const TIM_CONFIG = {
  SDKAppID: 0, // 需要替换为实际的 SDKAppID
};

// 存储 TIM 实例
let tim = null;
// 存储 TRTC 实例
let trtcClient = null;
let localStream = null;
let remoteStreams = {};

/**
 * 初始化 TIM SDK
 * @param {Object} config - 配置参数
 * @param {number} config.sdkAppID - SDKAppID
 * @param {string} config.userID - 用户 ID
 * @param {string} config.userSig - 用户签名
 * @param {boolean} config.debugMode - 是否开启调试模式
 * @returns {Promise}
 */
export function initTIM(config) {
  return new Promise((resolve, reject) => {
    try {
      // 创建 TIM 实例
      tim = TIM.create({
        SDKAppID: config.sdkAppID || TIM_CONFIG.SDKAppID,
      });

      // 设置日志级别
      if (config.debugMode) {
        tim.setLogLevel(1); // 普通级别，日志量较多
      } else {
        tim.setLogLevel(4); // 无日志级别
      }

      // 监听 TIM 事件
      tim.on(TIM.EVENT.SDK_READY, handleSDKReady);
      tim.on(TIM.EVENT.MESSAGE_RECEIVED, handleMessageReceived);
      tim.on(TIM.EVENT.SDK_NOT_READY, handleSDKNotReady);
      tim.on(TIM.EVENT.KICKED_OUT, handleKickedOut);
      tim.on(TIM.EVENT.ERROR, handleError);
	
	    console.log('登录 TIM config', config)
	
      // 登录 TIM
      tim.login({
        userID: config.userID,
        userSig: config.userSig,
      }).then((imResponse) => {
        console.log('TIM 登录成功:', imResponse);
        // 暴露 TIM 实例到全局，供 chat-panel 等子组件使用
        try { getApp().globalData.tim = tim; } catch (e) {}
        resolve(tim);
      }).catch((imError) => {
        console.error('TIM 登录失败:', imError);
        reject(imError);
      });
    } catch (error) {
      console.error('TIM 初始化失败:', error);
      reject(error);
    }
  });
}

/**
 * 初始化 TRTC 客户端
 * @param {Object} config - 配置参数
 * @param {string} config.roomID - 房间 ID
 * @param {string} config.userID - 用户 ID
 * @param {string} config.userSig - 用户签名
 * @returns {Promise}
 */
export function initTRTC(config) {
	console.log('initTRTC config：', config)
  return new Promise((resolve, reject) => {
    try {
      // 创建 TRTC 客户端
      trtcClient = TRTC.createClient({
        sdkAppId: config.sdkAppID || TIM_CONFIG.SDKAppID,
        userId: config.userId,
        userSig: config.userSig,
        mode: 'rtc',
      });

      // 监听 TRTC 事件
      trtcClient.on('stream-added', handleStreamAdded); // 订阅远程流
      trtcClient.on('stream-subscribed', handleStreamSubscribed); // 远程流订阅成功
      trtcClient.on('stream-removed', handleStreamRemoved); // 远程流移除
      trtcClient.on('peer-leave', handlePeerLeave); // 远端用户离开
      trtcClient.on('error', handleTRTCError); // 错误处理

      // 加入房间
      trtcClient.join({
        roomId: config.roomId,
      }).then(() => {
        console.log('加入房间成功');
        // 创建本地流
        createLocalStream().then((stream) => {
          localStream = stream;
          // 发布本地流
          trtcClient.publish(localStream).then(() => {
            console.log('发布本地流成功');
            resolve({ localStream, trtcClient });
          }).catch((error) => {
            console.error('发布本地流失败:', error);
            reject(error);
          });
        }).catch((error) => {
          console.error('创建本地流失败:', error);
          reject(error);
        });
      }).catch((error) => {
        console.error('加入房间失败:', error);
        reject(error);
      });
    } catch (error) {
      console.error('TRTC 初始化失败:', error);
      reject(error);
    }
  });
}

/**
 * 创建本地流
 * @returns {Promise}
 */
function createLocalStream() {
  return new Promise((resolve, reject) => {
    try {
      const stream = TRTC.createStream({
        audio: true,
        video: true,
        screen: false,
      });

      // 初始化流
      stream.initialize().then(() => {
        console.log('本地流初始化成功');
        resolve(stream);
      }).catch((error) => {
        console.error('本地流初始化失败:', error);
        reject(error);
      });
    } catch (error) {
      console.error('创建本地流异常:', error);
      reject(error);
    }
  });
}

/**
 * 订阅远程流
 * @param {Object} event - 事件对象
 */
function handleStreamAdded(event) {
  const remoteStream = event.stream;
  console.log('检测到远程流:', remoteStream.getUserId());
  // 订阅远程流
  trtcClient.subscribe(remoteStream);
}

/**
 * 远程流订阅成功
 * @param {Object} event - 事件对象
 */
function handleStreamSubscribed(event) {
  const remoteStream = event.stream;
  const userId = remoteStream.getUserId();
  console.log('订阅远程流成功:', userId);
  remoteStreams[userId] = remoteStream;
  // 触发远程流添加事件，可以在这里更新 UI
  window.dispatchEvent(new CustomEvent('remote-stream-added', {
    detail: { userId, stream: remoteStream }
  }));
}

/**
 * 远程流移除
 * @param {Object} event - 事件对象
 */
function handleStreamRemoved(event) {
  const remoteStream = event.stream;
  const userId = remoteStream.getUserId();
  console.log('远程流移除:', userId);
  if (remoteStreams[userId]) {
    // 停止播放
    remoteStreams[userId].stop();
    delete remoteStreams[userId];
    // 触发远程流移除事件
    window.dispatchEvent(new CustomEvent('remote-stream-removed', {
      detail: { userId }
    }));
  }
}

/**
 * 远端用户离开
 * @param {Object} event - 事件对象
 */
function handlePeerLeave(event) {
  const userId = event.userId;
  console.log('远端用户离开:', userId);
  if (remoteStreams[userId]) {
    // 停止播放
    remoteStreams[userId].stop();
    delete remoteStreams[userId];
    // 触发用户离开事件
    window.dispatchEvent(new CustomEvent('peer-leave', {
      detail: { userId }
    }));
  }
}

/**
 * TIM SDK 就绪
 * @param {Object} event - 事件对象
 */
function handleSDKReady(event) {
  console.log('TIM SDK 就绪');
  // 触发 SDK 就绪事件
  window.dispatchEvent(new CustomEvent('tim-sdk-ready', {
    detail: { event }
  }));
}

/**
 * 收到消息
 * @param {Object} event - 事件对象
 */
function handleMessageReceived(event) {
  console.log('收到消息:', event);
  // 触发收到消息事件
  window.dispatchEvent(new CustomEvent('tim-message-received', {
    detail: { event }
  }));
}

/**
 * TIM SDK 未就绪
 * @param {Object} event - 事件对象
 */
function handleSDKNotReady(event) {
  console.log('TIM SDK 未就绪');
  // 触发 SDK 未就绪事件
  window.dispatchEvent(new CustomEvent('tim-sdk-not-ready', {
    detail: { event }
  }));
}

/**
 * 被踢下线
 * @param {Object} event - 事件对象
 */
function handleKickedOut(event) {
  console.log('被踢下线:', event);
  // 触发被踢下线事件
  window.dispatchEvent(new CustomEvent('tim-kicked-out', {
    detail: { event }
  }));
}

/**
 * 错误处理
 * @param {Object} event - 事件对象
 */
function handleError(event) {
  console.error('TIM 错误:', event);
  // 触发错误事件
  window.dispatchEvent(new CustomEvent('tim-error', {
    detail: { event }
  }));
}

/**
 * TRTC 错误处理
 * @param {Object} event - 事件对象
 */
function handleTRTCError(event) {
  console.error('TRTC 错误:', event);
  // 触发 TRTC 错误事件
  window.dispatchEvent(new CustomEvent('trtc-error', {
    detail: { event }
  }));
}

/**
 * 退出房间并销毁资源
 * @returns {Promise}
 */
export function exitRoom() {
  return new Promise((resolve, reject) => {
    try {
      // 停止发布本地流
      if (localStream) {
        localStream.stop();
        localStream = null;
      }

      // 停止订阅所有远程流
      Object.values(remoteStreams).forEach((stream) => {
        stream.stop();
      });
      remoteStreams = {};

      // 离开房间
      if (trtcClient) {
        trtcClient.leave().then(() => {
          console.log('离开房间成功');
          // 销毁 TRTC 客户端
          trtcClient = null;
          resolve();
        }).catch((error) => {
          console.error('离开房间失败:', error);
          reject(error);
        });
      } else {
        resolve();
      }
    } catch (error) {
      console.error('退出房间异常:', error);
      reject(error);
    }
  });
}

/**
 * 登出 TIM
 * @returns {Promise}
 */
export function logoutTIM() {
  return new Promise((resolve, reject) => {
    try {
      if (tim) {
        tim.logout().then((imResponse) => {
          console.log('TIM 登出成功:', imResponse);
          // 移除所有事件监听
          tim.off(TIM.EVENT.SDK_READY, handleSDKReady);
          tim.off(TIM.EVENT.MESSAGE_RECEIVED, handleMessageReceived);
          tim.off(TIM.EVENT.SDK_NOT_READY, handleSDKNotReady);
          tim.off(TIM.EVENT.KICKED_OUT, handleKickedOut);
          tim.off(TIM.EVENT.ERROR, handleError);
          tim = null;
          resolve();
        }).catch((imError) => {
          console.error('TIM 登出失败:', imError);
          reject(imError);
        });
      } else {
        resolve();
      }
    } catch (error) {
      console.error('登出 TIM 异常:', error);
      reject(error);
    }
  });
}

/**
 * 开关麦克风
 * @param {boolean} enabled - 是否开启麦克风
 * @returns {Promise}
 */
export function openCloseMicrophone(enabled) {
  return new Promise((resolve, reject) => {
    try {
      if (localStream) {
        if (enabled) {
          localStream.unmuteAudio();
        } else {
          localStream.muteAudio();
        }
        resolve();
      } else {
        reject(new Error('本地流未初始化'));
      }
    } catch (error) {
      console.error('切换麦克风失败:', error);
      reject(error);
    }
  });
}

/**
 * 开关摄像头
 * @param {boolean} enabled - 是否开启摄像头
 * @returns {Promise}
 */
export function openCloseCamera(enabled) {
  return new Promise((resolve, reject) => {
    try {
      if (localStream) {
        if (enabled) {
          localStream.unmuteVideo();
        } else {
          localStream.muteVideo();
        }
        resolve();
      } else {
        reject(new Error('本地流未初始化'));
      }
    } catch (error) {
      console.error('切换摄像头失败:', error);
      reject(error);
    }
  });
}

// 获取摄像头列表
export function getCamera() {
	console.log('进入了获取摄像头列表 getCamera')
	return new Promise((resolve, reject) => {
		try {
			console.log('客户端实例：', TRTC)
			TRTC.getCameras().then(devices => {
				devices.forEach(dev => {
					console.log('camera label: ' + dev.label + ' deviceId: ' + dev.deviceId);
				});
				resolve(devices)
			}).catch(error => {
				reject(error)
			})
		} catch (error) {
			console.error('获取摄像头失败:', error);
			reject(error);
		}
	});
}

/**
 * 是否开启扬声器
 * @param {boolean} enabled - 是否使用扬声器
 * @returns {Promise}
 */
export function openCloseSpeaker(enabled) {
  return new Promise(async (resolve, reject) => {
    try {
		await TRTC.muteRemoteAudio('*', enabled); // 静音所有远端用户
		 //  // 对于 H5，需要遍历所有远程流并设置扬声器
		 //  Object.values(remoteStreams).forEach((stream) => {
			// const audioElement = document.getElementById(`remote-audio-${stream.getUserId()}`);
			// if (audioElement) {
			//   audioElement.muted = !enabled;
			//   // 对于 Safari 浏览器，需要额外处理
			//   if (enabled) {
			// 	audioElement.setSinkId('speaker').catch((error) => {
			// 	  console.warn('设置扬声器失败:', error);
			// 	});
			//   }
			// }
		 //  });
      resolve();
    } catch (error) {
      console.error('切换扬声器失败:', error);
      reject(error);
    }
  });
}

// 导出 TIM 和 TRTC 以供外部使用
export { TIM, TRTC };