import {
	startPhoneListener,
	stopPhoneListener,
	checkIsAutoRecord,
	toCallAutoRecorderPage,
	navigateToCallRecordingSettings,
	jumpToPermissionPage,
	allRecorderFilesAction
} from '@/uni_modules/yao-lister';
import permision from "@/js_sdk/wa-permission/permission.js";
import { formatPhoneNumber, simpleDebounce } from '../../utils/util';

export default {
	namespaced: true,
	state: {
		filelist: [],
		isAutoRecord: false, // 通话自动录音状态
		hasStoragePermission: false, // 文件访问权限状态
		hasReadPhoneStatePermission: false, // 读取手机状态权限
		hasCallPhonePermission: false, // 拨打电话权限
		hasReadCallLogPermission: false, // 读取通话记录权限
		hasReadPhoneNumbersPermission: false, // 读取电话号码权限
		isPhoneListening: false, // 电话监听状态
		form: {
			clueId: undefined,
			fileUrl : undefined,
			fileName : undefined,
			type : '3',
			list : [],
			caller : '',
			callee : ''
		},
	},
	mutations: {
		SET_FILE_LIST: (state, data) => {
			state.filelist = data.data
		},
		SET_AUTO_RECORD: (state, value) => {
			state.isAutoRecord = value;
		},
		SET_STORAGE_PERMISSION: (state, value) => {
			state.hasStoragePermission = value;
		},
		SET_READ_PHONE_STATE_PERMISSION: (state, value) => {
			state.hasReadPhoneStatePermission = value;
		},
		SET_CALL_PHONE_PERMISSION: (state, value) => {
			state.hasCallPhonePermission = value;
		},
		SET_READ_CALL_LOG_PERMISSION: (state, value) => {
			state.hasReadCallLogPermission = value;
		},
		SET_READ_PHONE_NUMBERS_PERMISSION: (state, value) => {
			state.hasReadPhoneNumbersPermission = value;
		},
		SET_PHONE_LISTENING_STATUS: (state, value) => {
			state.isPhoneListening = value;
		},
		SET_CALLER_PHONE: (state, phoneNumber) => {
			state.form.caller = phoneNumber;
		},
		SET_FORM: (state, data) => {
			state.form = data;
		},
	},
	actions: {
		getFileList({dispatch,state, commit}) {
			dispatch("checkStoragePermission").then(()=>{
				if(state.hasStoragePermission){
					allRecorderFilesAction(res => {
						if(res && res.length > 0) {
							// 将文件路径数组转换为包含filePath和fileName的对象数组
							const fileListPromise = res.map(filePath => {
								return new Promise((resolve) => {
									// 从路径中提取文件名
									const fileName = filePath.split('/').pop();
									
									// 获取文件信息，包括创建时间
									plus.io.resolveLocalFileSystemURL(filePath, (entry) => {
										entry.getMetadata((metadata) => {
											resolve({
												filePath: filePath,
												fileName: fileName,
												createTime: metadata.modificationTime ? metadata.modificationTime : 0, // 文件创建时间
											});
										}, (error) => {
											// 如果获取metadata失败，返回基本信息
											resolve({
												filePath: filePath,
												fileName: fileName,
												createTime: 0, // 设为0，排序时会在最前面
											});
										});
									}, (error) => {
										// 如果解析文件路径失败，返回基本信息
										resolve({
											filePath: filePath,
											fileName: fileName,
											createTime: 0,
											size: 0
										});
									});
								});
							});
							
							// 等待所有文件信息获取完成后进行排序
							Promise.all(fileListPromise).then((fileList) => {
								// 按创建时间排序，最新的文件排在前面（降序）
								fileList.sort((a, b) => {
									return b.createTime - a.createTime;
								});
								
								// 提交文件列表到state
								commit('SET_FILE_LIST', { data: fileList });
							}).catch((error) => {
								console.error('获取文件列表失败:', error);
								// 即使排序失败，也尝试提交原始列表
								const fallbackFileList = res.map(filePath => {
									const fileName = filePath.split('/').pop();
									return {
										filePath: filePath,
										fileName: fileName
									};
								});
								commit('SET_FILE_LIST', { data: fallbackFileList });
							});
						}
					})
				}else{
					dispatch("requestStoragePermission");
				}
			})
			
		},

		// 获取用户手机号码
		getUserPhoneNumber({ commit }) {
			return new Promise((resolve, reject) => {
				// 首先检查权限
				permision.requestAndroidPermission('android.permission.READ_PHONE_NUMBERS')
					.then(result => {
						if (result === 1) {
							// 权限被授予，获取手机号码
							try {
								const main = plus.android.runtimeMainActivity();
								const Context = plus.android.importClass('android.content.Context');
								const TelephonyManager = plus.android.importClass('android.telephony.TelephonyManager');
								
								const telephonyManager = main.getSystemService(Context.TELEPHONY_SERVICE);
								const phoneNumber = telephonyManager.getLine1Number();
								
								if (phoneNumber && phoneNumber.trim() !== '') {
									// 移除国际区号，保留手机号码
									const cleanPhoneNumber = formatPhoneNumber(phoneNumber);
									commit('SET_CALLER_PHONE', cleanPhoneNumber);
									resolve(cleanPhoneNumber);
								} else {
									// 如果获取不到手机号码，尝试使用备选方法
									try {
										const SubscriptionManager = plus.android.importClass('android.telephony.SubscriptionManager');
										const subscriptionManager = main.getSystemService(Context.TELEPHONY_SERVICE);
										const activeSubscriptionInfoList = subscriptionManager.getActiveSubscriptionInfoList();
										
										if (activeSubscriptionInfoList && activeSubscriptionInfoList.size() > 0) {
											const subscriptionInfo = activeSubscriptionInfoList.get(0);
											const number = subscriptionInfo.getNumber();
											if (number && number.trim() !== '') {
												// 移除国际区号，保留手机号码
												const cleanPhoneNumber = formatPhoneNumber(number);
												commit('SET_CALLER_PHONE', cleanPhoneNumber);
												resolve(cleanPhoneNumber);
											} else {
												reject(new Error('无法获取手机号码：SIM卡可能未激活或号码无效'));
											}
										} else {
											reject(new Error('无法获取手机号码：未检测到有效的SIM卡'));
										}
									} catch (fallbackError) {
										console.error('备选方法获取手机号码失败:', fallbackError);
										reject(new Error('无法获取手机号码：设备可能不支持或运营商限制'));
									}
								}
							} catch (error) {
								console.error('获取手机号码失败:', error);
								reject(new Error('获取手机号码失败: ' + error.message));
							}
						} else {
							reject(new Error('没有获取手机号码的权限，请前往设置开启权限'));
						}
					})
					.catch(error => {
						console.error('请求权限失败:', error);
						reject(error);
					});
			});
		},

		// 检查所有权限状态
		checkAllPermissions({ commit }) {
			return new Promise((resolve, reject) => {
				try {
					// 检查通话自动录音状态
					const autoRecordStatus = checkIsAutoRecord();
					commit('SET_AUTO_RECORD', autoRecordStatus);

					// 检查文件访问权限
					this.dispatch('call/checkStoragePermission').then(storagePermission => {
						commit('SET_STORAGE_PERMISSION', storagePermission);

						// 检查其他权限
						const permissions = [
							{
								id: 'android.permission.READ_PHONE_STATE',
								mutation: 'SET_READ_PHONE_STATE_PERMISSION'
							},
							{
								id: 'android.permission.CALL_PHONE',
								mutation: 'SET_CALL_PHONE_PERMISSION'
							},
							{
								id: 'android.permission.READ_CALL_LOG',
								mutation: 'SET_READ_CALL_LOG_PERMISSION'
							},
							{
								id: 'android.permission.READ_PHONE_NUMBERS',
								mutation: 'SET_READ_PHONE_NUMBERS_PERMISSION'
							}
						];

						const permissionPromises = permissions.map(perm => {
							return permision.requestAndroidPermission(perm.id).then(result => {
								commit(perm.mutation, result === 1);
								return { id: perm.id, granted: result === 1 };
							});
						});

						Promise.all(permissionPromises).then(results => {
								resolve({
									autoRecordStatus,
									storagePermission,
									permissions: results
								});
						});
					});
				} catch (error) {
					reject(error);
				}
			});
		},

		// 检查文件访问权限
		checkStoragePermission({ commit }) {
			return new Promise((resolve) => {
				let hasPermission = false;
				try {
					// 获取Android版本号
					let androidVersion = 0;
					uni.getSystemInfo({
						success: (res) => {
							if (res.system && res.system.includes('Android')) {
								const versionMatch = res.system.match(/Android (\d+\.?\d*)/);
								if (versionMatch && versionMatch[1]) {
									androidVersion = parseFloat(versionMatch[1]);
								}
							}

							if (androidVersion >= 11) {
								// Android 11及以上版本，使用MANAGE_EXTERNAL_STORAGE权限
								const Environment = plus.android.importClass('android.os.Environment');
								hasPermission = Environment.isExternalStorageManager();
								commit('SET_STORAGE_PERMISSION', hasPermission);
								resolve(hasPermission);
							} else {
								// Android 11以下版本，使用READ_EXTERNAL_STORAGE权限
								permision.requestAndroidPermission('android.permission.READ_EXTERNAL_STORAGE')
									.then(result => {
										hasPermission = result === 1;
										commit('SET_STORAGE_PERMISSION', hasPermission);
										resolve(hasPermission);
									});
							}
						}
					});
				} catch (e) {
					hasPermission = false;
					commit('SET_STORAGE_PERMISSION', hasPermission);
					resolve(hasPermission);
				}
			});
		},

		// 请求文件访问权限
		requestStoragePermission() {
			jumpToPermissionPage();
		},

		// 跳转到通话录音设置页面
		toCallRecorderSettings() {
			toCallAutoRecorderPage();
		},

		// 跳转到系统通话录音界面
		toSystemRecorderSettings() {
			navigateToCallRecordingSettings();
		},

		// 打开系统设置
		handleOpenSet() {
			permision.gotoAppPermissionSetting('android.permission.RECORD_AUDIO');
		},

		// 启动电话监听
		startPhoneListener({ commit, dispatch , state }) {
			try {
				if(state.isPhoneListening){
					// 已经开启监听就不要了
					return;
				}
				dispatch("checkAllPermissions").finally(()=>{
					startPhoneListener(res => {
						simpleDebounce(()=>{
							// 毕竟重复监听 套一个防抖
							dispatch("handleCallBack");
						},500)
						// 14:44:54.429 空闲状态,  监听结果============================== at store/modules/call.js:324
						
						// 14:47:29.570 state=12== 2 13417106969
						
						// 14:47:29.570 phoneState 通话中
						
						// 14:47:29.571 通话中,  监听结果============================== at store/modules/call.js:324
						
						// 14:47:35.712 state=12== 0 13417106969
						
						// 14:47:35.713 phoneState 空闲状态
						
						// 14:47:35.728 空闲状态,  监听结果============================== at store/modules/call.js:324
						
						// 14:47:36.220 state=12== 0 13417106969
						
						// 14:47:36.220 phoneState 空闲状态
						
						// 14:47:36.220 空闲状态,  监听结果============================== at store/modules/call.js:324
						console.log(res, "监听结果==============================");
						commit('SET_PHONE_LISTENING_STATUS', true);
					});
				});
			} catch (error) {
				console.error('启动电话监听失败:', error);
				commit('SET_PHONE_LISTENING_STATUS', false);
				throw error;
			}
		},
		handleCallBack(){
			
		},
		// 停止电话监听
		stopPhoneListener({ commit }) {
			try {
				stopPhoneListener(res => {
					console.log(res, "3123123123");
					commit('SET_PHONE_LISTENING_STATUS', false);
				});
			} catch (error) {
				console.error('停止电话监听失败:', error);
				commit('SET_PHONE_LISTENING_STATUS', false);
				throw error;
			}
		},

		// 切换电话监听状态
		togglePhoneListener({ state, dispatch }) {
			if (state.isPhoneListening) {
				return dispatch('stopPhoneListener');
			} else {
				return dispatch('startPhoneListener');
			}
		}
	},
}