// 云端基础URL
const BASE_URL = 'https://cloud.yuxindazhineng.com'
// const BASE_URL = 'https://cloudtest.yuxindazhineng.com'
// const BASE_URL = 'https://yxdpqj.yuxindazhineng.com'

// 登录请求
export const login = async (username, password) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/login`,
			method: "POST",
			data: {
				"username": username,
				"password": password,
				"login_type": "phone"
			},
			header: {
				'Content-Type': 'application/json'
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const token = res.data.access_token
					if (token) {
						uni.setStorageSync('token', token)
						resolve(token)
					} else {
						const msg = res.data.error || '检查用户名和密码'
						reject(msg)
					}
				} else {
					reject(`请求失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 历史会话请求
export const getUserConversations = async (token) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/get_user_conversations`,
			method: "POST",
			data: {
				"access_token": token
			},
			header: {
				'Content-Type': 'application/json'
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const conversations = res.data.conversations
					resolve(conversations)

				} else {
					reject(`请求失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 获取与AI的对话内容
export const getConversationMessages = async (token, conversatio_id) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/get_conversation_messages`,
			method: 'POST',
			data: {
				"access_token": token,
				"login_type": "phone",
				"conversation_id": conversatio_id
			},
			header: {
				'Content-Type': 'application/json'
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const messagesInfo = res.data
					if (messagesInfo) {
						console.log("工作区id为：", messagesInfo.workspace_id || '(无)');
						if (messagesInfo.workspace_id) {
							uni.setStorageSync('workspace_id', messagesInfo.workspace_id)
						}
						resolve(messagesInfo.messages)
					} else {
						const msg = res.data.error || '获取消息出错啦'
						reject(msg)
					}
				} else {
					reject(`请求失败：${res.statusCode}`)
				}

			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 用户发送消息（ai不接收/回复）
export const addMessageDict = async (token, role, conversation_id, message) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/add_message_dict`,
			method: "POST",
			data: {
				"access_token": token,
				"conversation_id": conversation_id,
				"message": {
					"role": role,
					"content": message
				}
			},
			header: {
				'Content-Type': 'application/json'
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const message_id = res.data.message_id
					if (message_id) {
						resolve(message_id)
					} else {
						const msg = res.data.error || '用户发送消息出错啦'
						reject(msg)
					}
				} else {
					reject(`用户发送失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 获取工作区信息（非内容）
export const getWorkspaceByConversation = async (token, conversation_id) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/get_workspace_by_conversation`,
			method: "POST",
			data: {
				"access_token": token,
				"conversation_id": conversation_id
			},
			header: {
				'Content-Type': 'application/json'
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const workspaceInfo = res.data
					if (workspaceInfo?.success) {
						resolve(workspaceInfo.workspace_id)
					} else {
						const msg = res.data.error || '获取工作区信息出错啦'
						reject(msg)
					}
				} else {
					reject(`获取工作区信息失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})


	})
}


// 创建工作区id
export const createWorkspace = async (token, name) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/create_workspace`,
			method: "POST",
			data: {
				"access_token": token,
				"name": name
			},
			header: {
				'Content-Type': 'application/json'
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const workspaceId = res.data.workspace_id
					if (workspaceId) {
						resolve(workspaceId)
					} else {
						const msg = res.data.error || '创建工作区id出错啦'
						reject(msg)
					}
				} else {
					reject(`创建工作区id失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 创建新对话
export const createConversation = async (token, workspaceId, title, sender) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/create_conversation`,
			method: "POST",
			data: {
				"access_token": token,
				"workspace_id": workspaceId,
				"title": title,
				"sender": sender
			},
			header: {
				'Content-Type': 'application/json'
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const conversationId = res.data.conversation_id
					if (conversationId) {
						resolve(conversationId)
					} else {
						const msg = res.data.error || '创建新对话id出错啦'
						reject(msg)
					}
				} else {
					reject(`创建新对话失败：${res.statusCode}`)
				}
			}
		})
	})
}


// 删除会话
export const deleteConversation = async (token, conversation_ids) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/delete_conversation`,
			method: "POST",
			data: {
				"access_token": token,
				"conversation_ids": conversation_ids
			},
			header: {
				'Content-Type': 'application/json'
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond?.success) {
						resolve(respond.message)
					} else {
						const msg = respond.failed_ids.error || '删除对话出错啦'
						reject(msg)
					}
				} else {
					reject(`删除对话失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 获取用户信息
export const getUserInfo = async (token) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/get_user_info`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond?._id) {
						uni.setStorageSync('userId', respond._id)
						resolve(respond)
					} else {
						const msg = respond?.detail?.[0]?.msg || '获取用户信息出错啦'
						reject(msg)
					}
				} else {
					reject(`获取用户信息失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 获取用户头像（自己or好友组）
export const getUserAvatar = (token, userIds) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/get_user_avatar`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"user_ids": userIds
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.users)
					} else {
						const msg = respond?.error || '获取用户头像出错啦'
						reject(msg)
					}
				} else {
					reject(`获取用户头像失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}


// 通过用户名或邮箱来去查询用户
export const searchUsers = (token, keyword) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/search_users`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"keyword": keyword
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.users)
					} else {
						const msg = respond?.error || '通过用户名或邮箱来去查询用户出错啦'
						reject(msg)
					}
				} else {
					reject(`通过用户名或邮箱来去查询用户失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 工作区
// 获取工作区文件目录
export const getWorkspaceList = (token, workspacesId) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/phone/workspace/list`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"workspaces_id": workspacesId,
				"format": "tree",
				"parent_path": "",
				"filter_type": ""
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.data)
					} else {
						const msg = respond?.error || '获取工作区文件目录出错啦'
						reject(msg)
					}
				} else {
					reject(`获取工作区文件目录失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 删除工作区文件
export const daleteWorkspace = (token, workspacesId, path) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/phone/workspace/delete`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"workspaces_id": workspacesId,
				"file_path": path
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.message)
					} else {
						const msg = respond?.error || '删除工作区文件出错啦'
						reject(msg)
					}
				} else {
					reject(`删除工作区文件失败：${res.statusCode}`)
				}
			}
		})
	})
}

// 创建工作区文件夹（目录）
export const createWorkspaceFolder = (token, workspacesId, path) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/phone/workspace/create`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"workspaces_id": workspacesId,
				"dir_path": path
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.message)
					} else {
						const msg = respond?.error || '创建工作区文件夹出错啦'
						reject(msg)
					}
				} else {
					reject(`创建工作区文件夹失败：${res.statusCode}`)
				}
			}
		})
	})
}

// 获取工作区文件的URL
export const getWorkspaceFileURL = (token, workspacesId, path) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/phone/workspace/downloadFile`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"workspaces_id": workspacesId,
				"file_path": path
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					// 兼容两种返回格式：{success: true, message: [...]} 或直接返回数组
					if (respond.success) {
						resolve(respond.message || respond.data)
					} else if (Array.isArray(respond)) {
						resolve(respond)
					} else {
						const msg = respond?.error || '获取工作区文URL出错啦'
						reject(msg)
					}
				} else {
					reject(`获取工作区文URL失败：${res.statusCode}`)
				}
			}
		})
	})
}

// 上传文件（通过url）到工作区
export const workspaceUploadFileByURL = (token, workspacesId, urls, dirPath) => {
	return new Promise((resolve, reject) => {
		// urls 支持字符串或数组
		const urlList = Array.isArray(urls) ? urls : (urls ? [urls] : []);
		uni.request({
			url: `${BASE_URL}/cloud_api/phone/workspace/upload`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"workspaces_id": workspacesId,
				"dir_path": dirPath || '/',
				"urls": urlList
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data;
					// 接口返回: { success, total_files, success_count, failed_count, results: [{ url, success, error }], summary }
					if (respond.success) {
						resolve(respond);
					} else {
						// 部分/全部失败时，收集失败信息
						const failedItems = (respond.results || [])
							.filter(r => !r.success)
							.map(r => r.error || '未知错误');
						const msg = failedItems.length > 0
							? `上传失败 ${respond.failed_count}/${respond.total_files}：${failedItems[0]}`
							: (respond.summary || respond?.error || '上传文件到工作区出错啦');
						reject(msg);
					}
				} else {
					reject(`上传文件到工作区失败：${res.statusCode}`);
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误';
				reject(msg);
			}
		});
	});
};



// 上传文件（到短存云端）获取URL
// files: 文件数组，每个元素为 { path, name } 或字符串路径
// 返回格式: [{ url: "https://...", success: true }]
export const uploadFileToShortStorage = (workspacesId, files, filePath) => {
	return new Promise((resolve, reject) => {
		// 统一转为文件数组
		const fileList = Array.isArray(files) ? files : [files];

		// 构建 files 数组供 uni.uploadFile 使用
		const uploadFiles = fileList.map((file) => {
			const fileUri = typeof file === 'string' ? file : (file.tempFilePath || file.path || file);
			return {
				name: 'files',
				uri: fileUri
			};
		});

		console.log('uploadFileToShortStorage 参数:', { workspacesId, fileCount: uploadFiles.length, filePath });

		uni.uploadFile({
			url: `${BASE_URL}/cloud_api/file/temp/upload`,
			method: "POST",
			formData: {
				workspaces_id: workspacesId,
				file_path: filePath || '/',
				overwrite: 'true'
			},
			files: uploadFiles,
			success: (res) => {
				console.log('uploadFileToShortStorage 响应状态:', res.statusCode, '数据:', res.data);
				if (res.statusCode === 200) {
					try {
						const respond = JSON.parse(res.data);
						// 接口返回 [{ url, success }] 数组
						if (Array.isArray(respond) && respond.length > 0) {
							// 返回完整的 results 数组，调用方可遍历
							resolve(respond);
						} else if (respond.success) {
							// 兼容 { success: true, url: "..." } 格式
							resolve([{ url: respond.url || respond.message, success: true }]);
						} else {
							const msg = respond?.error || respond?.message || '上传文件（到短存云端）获取URL出错啦';
							reject(msg);
						}
					} catch (e) {
						reject('接口返回数据格式异常: ' + res.data);
					}
				} else {
					reject(`上传文件（到短存云端）获取URL失败：${res.statusCode} - ${res.data}`);
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误';
				reject(msg);
			}
		});
	});
};

// 重命名工作区文件/文件夹(电脑端)
export const updateWorkspaceFileName = (token, workspacesId, oldPath, newName) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/workspace/file/rename`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"workspaces_id": workspacesId,
				"file_path": oldPath,
				"new_name": newName
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data;
					if (respond.success) {
						resolve(respond.message || respond);
					} else {
						const msg = respond?.error || '重命名工作区文件出错啦';
						reject(msg);
					}
				} else {
					reject(`重命名工作区文件失败：${res.statusCode}`);
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误';
				reject(msg);
			}
		});
	});
};

// 上传用户头像
export const uploadUserAvatar = (token, userId, username, email, avatarURL) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/user/file/upload`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"file": file,
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.upload_url)
					} else {
						const msg = respond?.error || '上传用户头像出错啦'
						reject(msg)
					}
				} else {
					reject(`上传用户头像失败：${res.statusCode}`)
				}
			}
		})
	})
}


// 修改用户信息
export const updateUserInfo = (token, userId, username, email, avatarURL) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/update_user_profile`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"user_id": userId,
				"username": username,
				"email:": email,
				"avatar": avatarURL
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.message)
					} else {
						const msg = respond?.error || '修改用户信息出错啦'
						reject(msg)
					}
				} else {
					reject(`修改用户信息失败：${res.statusCode}`)
				}
			}
		})
	})
}

// ============================云端文件管理=========================
// 获取云端个人/团队文件列表
export const getCloudFileList = (token, type, path = "/", teamId = "") => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/file/list`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"path": path,
				"type": type,
				"team_id": teamId
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.data)
					} else {
						const msg = respond?.error || '获取工作区文件目录出错啦'
						reject(msg)
					}
				} else {
					reject(`获取工作区文件目录失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 下载云端文件，通过文件id获取下载url
export const getCloudFileUrl = (token, fileId) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/file/download`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"file_id": fileId,
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.data.download_url)
					} else {
						const msg = respond?.error || '获取云端文件url出错啦'
						reject(msg)
					}
				} else {
					reject(`获取云端文件url失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}


// 删除云端文件
export const deleteCloudFile = (token, fileId) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/file/delete`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"file_id": fileId
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.message)
					} else {
						const msg = respond?.error || '删除云端文件出错啦'
						reject(msg)
					}
				} else {
					reject(`删除云端文件失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 批量上传云端文件
export const uploadCloudFile = (token, type, path, files, team_id) => {
	return new Promise((resolve, reject) => {
		// 处理参数：team_id 转为字符串，空值置空
		const teamIdStr = team_id == null ? "" : String(team_id);

		uni.uploadFile({
			url: `${BASE_URL}/cloud_api/file/upload`,
			method: "POST",
			// 不要手动设置 Content-Type，浏览器自动生成 multipart/form-data
			header: {
				// 如果后端把token放header就写这里，放表单里就写到formData
			},
			// 普通文本参数（对应form-data里的文本项）
			formData: {
				access_token: token,
				path: path || "/",
				type: type,
				team_id: teamIdStr
			},
			// 多文件：每个文件name都叫files，和Postman保持一致
			files: files.map(fileItem => ({
				uri: fileItem.tempFilePath, // 文件本地临时路径
				name: "files"
			})),

			success: (res) => {
				if (res.statusCode === 200) {
					try {
						const respond = JSON.parse(res.data);
						if (respond.success) {
							resolve(respond.message);
						} else {
							const msg = respond?.error || '获取云端文件url出错啦';
							reject(msg);
						}
					} catch (e) {
						reject("接口返回数据格式异常");
					}
				} else {
					reject(`获取云端文件url失败：${res.statusCode}`);
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误';
				reject(msg);
			}
		});
	});
};


// 获取用户可访问的团队列表
export const getTeamList = async (token) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/team/list`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				access_token: token,
				team_name: ""
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						const teamsList = respond.teams
						// 去掉第1条数据（系统团队），从下标1开始截取剩余所有
						const newList = teamsList.slice(1)
						resolve(newList)
					} else {
						const msg = res.data.error || '获取用户可访问的团队列表出错啦'
						reject(msg)
					}

				} else {
					reject(`获取用户可访问的团队列表失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 获取团队全部成员
export const getTeamAllMember = (token, teamId) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/team/get_all_member`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"team_id": teamId
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						const members = respond.team?.result || []
						resolve(members)
					} else {
						const msg = respond?.error || '获取团队全部成员出错啦'
						reject(msg)
					}
				} else {
					reject(`获取团队全部成员失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}


// 删除团队
export const deleteTeam = (token, teamId) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/team/delete`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"team_id": teamId
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.message)
					} else {
						const msg = respond?.error || '删除团队出错啦'
						reject(msg)
					}
				} else {
					reject(`删除团队失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 添加团队成员
export const addTeamMember = (token, teamId, userIds) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/team/add_member`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"team_id": teamId,
				"user_ids": userIds,
				"role": "admin"
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.message)
					} else {
						const msg = respond?.error || '添加团队成员出错啦'
						reject(msg)
					}
				} else {
					reject(`添加团队成员失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 修改团队信息
export const updateTeamInfo = (token, teamId, data) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/team/update`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"team_id": teamId,
				...data
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.message)
					} else {
						const msg = respond?.error || '修改团队信息出错啦'
						reject(msg)
					}
				} else {
					reject(`修改团队信息失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 移除团队成员
export const removeTeamMember = (token, teamId, userIds) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/team/remove_member`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"team_id": teamId,
				"user_ids": userIds
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.message)
					} else {
						const msg = respond?.error || '移除团队成员出错啦'
						reject(msg)
					}
				} else {
					reject(`移除团队成员失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 调整团员身份
export const updateTeamMemberRole = (token, teamId, userId, role) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/team/adjust_member_role`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"team_id": teamId,
				"user_id": userId,
				"role": role
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.message)
					} else {
						const msg = respond?.error || '调整团员身份出错啦'
						reject(msg)
					}
				} else {
					reject(`调整团员身份失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// ============================云端数据库=========================

// 获取用户可访问的数据库列表
export const getCloudDbList = (token) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/database/list`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						// "databases": [
						// 		{
						// 			"database_name": "测试3",
						// 			"table_count": 0,
						// 			"file_path": "/home/yxd/yxd-agent-cloud/databases/6a446df3060ba5feae589c22.db",
						// 			"modified_time": 1782869492.6399229,
						// 			"database_id": "6a446df3060ba5feae589c22",
						// 			"user_id": "690c72a6b8ffa329af2d5607",
						// 			"access_level": 2
						// 		},
						// 		{
						// 			"database_name": "database1",
						// 			"table_count": 0,
						// 			"file_path": "/home/yxd/yxd-agent-cloud/databases/6a446bfa1db19f3506901d2d.db",
						// 			"modified_time": 1782868987.3745258,
						// 			"database_id": "6a446bfa1db19f3506901d2d",
						// 			"team_id": "6a02f6f0d99a03faefd1f437",
						// 			"access_level": 2
						// 		}
						// 	],
						resolve(respond.databases)
					} else {
						const msg = respond?.error || '获取用户可访问的数据库列表出错啦'
						reject(msg)
					}
				} else {
					reject(`获取用户可访问的数据库列表失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 创建数据库(仅个人可创建)
export const createCloudDb = (token, databaseName) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/database/create`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"database_name": databaseName
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.message)
					} else {
						const msg = respond?.error || '创建数据库出错啦'
						reject(msg)
					}
				} else {
					reject(`创建数据库失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 上传db文件（.db / .sqlite 等数据库文件）
export const uploadCloudDbFile = (token, filePath) => {
	return new Promise((resolve, reject) => {
		// filePath 可能是字符串路径或 { tempFilePath, name } 对象
		const fileUri = typeof filePath === 'string' ? filePath : (filePath.tempFilePath || filePath.path ||
			filePath);
		const fileName = typeof filePath === 'string' ?
			filePath.split('/').pop() || 'database.db' :
			(filePath.name || 'database.db');

		uni.uploadFile({
			url: `${BASE_URL}/cloud_api/database/upload/db`,
			method: "POST",
			header: {},
			formData: {
				access_token: token
			},
			file: {
				name: fileName,
				uri: fileUri
			},
			files: [{
				name: 'file',
				uri: fileUri
			}],
			success: (res) => {
				if (res.statusCode === 200) {
					try {
						const respond = JSON.parse(res.data);
						if (respond.success) {
							resolve(respond.message);
						} else {
							const msg = respond?.error || '上传db出错啦';
							reject(msg);
						}
					} catch (e) {
						reject("接口返回数据格式异常");
					}
				} else {
					reject(`上传db失败：${res.statusCode}`);
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误';
				reject(msg);
			}
		});
	});
};



// 删除数据库(仅个人可创建)
export const deleteCloudDb = (token, databaseId) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/database/delete`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"database_id": databaseId
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.message)
					} else {
						const msg = respond?.error || '删除数据库出错啦'
						reject(msg)
					}
				} else {
					reject(`删除数据库失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 获取数据库中的表列表
export const getCloudDbTables = (token, databaseId, isDetail) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/database/tables`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"database_id": databaseId,
				"is_detail": isDetail
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.tables)
					} else {
						const msg = respond?.error || '获取用户可访问的数据库列表出错啦'
						reject(msg)
					}
				} else {
					reject(`获取用户可访问的数据库列表失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 获取表数据
export const getCloudDbTableData = (token, databaseId, tableName, limit = "20", offset = "0") => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/database/table/data`,
			method: "POST",
			header: {
				'Content-Type': 'application/json'
			},
			data: {
				"access_token": token,
				"database_id": databaseId,
				"table_name": tableName,
				"limit": limit,
				"offset": offset
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond.success) {
						resolve(respond.data)
					} else {
						const msg = respond?.error || '获取表数据出错啦'
						reject(msg)
					}
				} else {
					reject(`获取表数据失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}


// 删除数据库中的表
export const deleteCloudDbTable = async (token, databaseId, tableName) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/database/table/drop`,
			method: "POST",
			data: {
				"access_token": token,
				"database_id": databaseId,
				"table_name": tableName
			},
			header: {
				'Content-Type': 'application/json'
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond?.success) {
						resolve(respond.message)
					} else {
						const msg = respond.error || '删除数据库中的表出错啦'
						reject(msg)
					}
				} else {
					reject(`删除数据库中的表失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 更新表数据
export const updateCloudDbTableData = (token, databaseId, tableName, whereData, updateData) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/database/table/update/by/id`,
			method: "POST",
			data: {
				"access_token": token,
				"database_id": databaseId,
				"table_name": tableName,
				"where_data": whereData,
				"update_data": updateData
			},
			header: {
				'Content-Type': 'application/json'
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond?.success) {
						resolve(respond.message)
					} else {
						const msg = respond.error || '更新表数据出错啦'
						reject(msg)
					}
				} else {
					reject(`更新表数据失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}


// 导入文件到数据库
export const importFileToCloudDb = (token, forceOverwrite, databaseId, filePath, tableName) => {
	return new Promise((resolve, reject) => {
		// filePath 可能是字符串路径或 { tempFilePath, name } 对象
		const fileUri = typeof filePath === 'string' ? filePath : (filePath.tempFilePath || filePath.path ||
			filePath);
		const fileName = typeof filePath === 'string' ?
			filePath.split('/').pop() || 'file' :
			(filePath.name || 'file');

		uni.uploadFile({
			url: `${BASE_URL}/cloud_api/database/import`,
			method: "POST",
			header: {},
			formData: {
				access_token: token,
				force_overwrite: forceOverwrite,
				database_id: databaseId,
				table_name: tableName
			},
			// uni.uploadFile 的 file 参数需要是对象格式：{ name, uri }
			file: {
				name: fileName,
				uri: fileUri
			},
			// 同时用 files 方式兜底
			files: [{
				name: 'file',
				uri: fileUri
			}],

			success: (res) => {
				if (res.statusCode === 200) {
					try {
						const respond = JSON.parse(res.data);
						if (respond.success) {
							resolve(respond.message);
						} else {
							const msg = respond?.error || '导入文件到数据库出错啦';
							reject(msg);
						}
					} catch (e) {
						reject("接口返回数据格式异常");
					}
				} else {
					reject(`导入文件到数据库失败：${res.statusCode}`);
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误';
				reject(msg);
			}
		});
	});
};

// 查看 个人/团队 数据库权限信息
export const getCloudDbPermission = (token, databaseId, type, id) => {
	return new Promise((resolve, reject) => {
		const requestData = {
			"access_token": token,
			"database_id": databaseId
		};
		// type 只能是 user_id 或 team_id
		if (type === 'user_id') {
			requestData.user_id = id;
		} else if (type === 'team_id') {
			requestData.team_id = id;
		}

		uni.request({
			url: `${BASE_URL}/cloud_api/database/permission/info`,
			method: "POST",
			data: requestData,
			header: {
				'Content-Type': 'application/json'
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond?.success) {
						// team_id 格式: { success: true, data: [...] }
						resolve(respond.data)
					} else if (Array.isArray(respond)) {
						// user_id 格式: 直接返回数组 [...]
						resolve(respond)
					} else {
						const msg = respond?.error || '查看 个人/团队 数据库权限信息出错啦'
						reject(msg)
					}
				} else {
					reject(`查看 个人/团队 数据库权限信息失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 删除 团队/用户 对数据库权限
export const deleteCloudDbPermission = (token, databaseId, type, id) => {
	return new Promise((resolve, reject) => {
		const requestData = {
			"access_token": token,
			"database_id": databaseId
		};
		if (type === 'user_id') {
			requestData.user_id = id;
		} else if (type === 'team_id') {
			requestData.team_id = id;
		}

		uni.request({
			url: `${BASE_URL}/cloud_api/database/permission/delete`,
			method: "POST",
			data: requestData,
			header: {
				'Content-Type': 'application/json'
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond?.success) {
						resolve(respond.message)
					} else {
						const msg = respond.error || '删除 团队/用户 对数据库权限出错啦'
						reject(msg)
					}
				} else {
					reject(`删除 团队/用户 对数据库权限失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 修改/增加 团队/用户 对数据库权限
export const updateCloudDbPermission = (token, databaseId, type, id, level) => {
	return new Promise((resolve, reject) => {
		const requestData = {
			"access_token": token,
			"database_id": databaseId,
			"access_level": level
		};
		if (type === 'user_id') {
			requestData.user_id = id;
		} else if (type === 'team_id') {
			requestData.team_id = id;
		}

		uni.request({
			url: `${BASE_URL}/cloud_api/database/permission/update`,
			method: "POST",
			data: requestData,
			header: {
				'Content-Type': 'application/json'
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond?.success) {
						resolve(respond.message)
					} else {
						const msg = respond.error || '修改/增加 团队/用户 对数据库权限出错啦'
						reject(msg)
					}
				} else {
					reject(`修改/增加 团队/用户 对数据库权限失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}

// 个人数据库移交团队
export const dbTransferToTeam = async (token, databaseId, teamId) => {
	return new Promise((resolve, reject) => {
		uni.request({
			url: `${BASE_URL}/cloud_api/database/transfer_to_team`,
			method: "POST",
			data: {
				"access_token": token,
				"database_id": databaseId,
				"team_id": teamId
			},
			header: {
				'Content-Type': 'application/json'
			},
			success: (res) => {
				if (res.statusCode === 200) {
					const respond = res.data
					if (respond?.success) {
						resolve(respond.message)
					} else {
						const msg = respond.error || '个人数据库移交团队出错啦'
						reject(msg)
					}
				} else {
					reject(`个人数据库移交团队失败：${res.statusCode}`)
				}
			},
			fail: (err) => {
				const msg = err.errMsg || '网络错误'
				reject(msg)
			}
		})
	})
}