import {
	Base64
} from "js-base64";

export const BASE_PATH = "_documents/data/asmzx"; // 基础路径
export const SYNCHRONIZE_DATA_PATH = "_documents/data/asmzx"; //  同步数据
export const SYNCHRONIZE_DATA_PAD = "_documents/data/asmzx/pad"; // 存储pad端的生产数据
export const USER_FILE_NAME = "userList.txt"; // 存储内置用户的文件名
export const FILE_ENUM = {
	// 文件枚举
	fileSystemError: {
		code: 0,
		msg: "请求文件系统失败",
	},

	getDirectoryError: {
		code: 1,
		msg: "获取目录失败",
	},

	getFileError: {
		code: 2,
		msg: "获取文件失败",
	},

	readFileError: {
		code: 3,
		msg: "读取文件失败",
	},

	fileNotExist: {
		code: 4,
		msg: "文件不存在",
	},

	writeFileError: {
		code: 5,
		msg: "写入文件失败",
	},

	createFileError: {
		code: 6,
		msg: "创建文件失败",
	},

	deleteFileError: {
		code: 7,
		msg: "删除文件失败",
	},
	readDirectoryError: {
		code: 8,
		msg: "读取目录条目失败",
	},
	copyFileError: {
		code: 9,
		msg: "文件复制失败",
	},
};

// 内置的用户信息
export const USER_LiST = [
	//   name-> roleName
	// {
	//   userId: 1, // 有用
	//   user: "admin", // 有用 谁创建,谁有权限编辑和删除
	//   passWord: "JF123456", // 有用
	//   roleName: "超管", // 有用 -- 职位名称
	//   unitName: "超管所属单位", // 所属单位
	//   isAdmin: true, // 标识超管权限
	//   LastSynchronizationTime: "", // 上次同步时间
	// },
	{
		userId: 0, // 有用
		user: "叶一凡", // 有用 谁创建,谁有权限编辑和删除
		passWord: "123456", // 有用
		roleName: "运维", // 有用 -- 职位名称
		unitName: "运维", // 所属单位
		isAdmin: false, // 标识超管权限
		LastSynchronizationTime: "", // 上次同步时间
	},
	{
		userId: 262, // 有用
		user: "test1", // 有用 谁创建,谁有权限编辑和删除
		passWord: "JF123456", // 有用
		roleName: "巡检员", // 有用
		unitName: "巡检员1所属单位", // 所属单位
		isAdmin: false, // 标识超管权限
		LastSynchronizationTime: "", // 上次同步时间
	},
	{
		userId: 3, // 有用
		user: "test2", // 有用 谁创建,谁有权限编辑和删除
		passWord: "JF123456", // 有用
		roleName: "巡检员", // 有用
		unitName: "巡检员1所属单位", // 所属单位
		isAdmin: false, // 标识超管权限
		LastSynchronizationTime: "", // 上次同步时间
	},

];

/**
 * 【功能】： 检查是否含有指定目录，如果没有就创建目录
 *
 * 【文档地址】https://www.html5plus.org/doc/zh_cn/io.html#plus.io.PUBLIC_DOCUMENTS
 *
 *
 * 【备注】
 *  本地文件系统常量，Number类型，固定值3，对应相对路径URL为"_documents"开头的地址。
 *  安装包存在多个5+ App或uni-app环境时（如小程序SDK），所有5+ App或uni-app都可进行读写操作。
 *
 * 必须是：对应相对路径URL为"_documents"开头的地址。
 */

// 检查文件是否存在
export function checkAndCreateDirectory(directoryPath) {
	return new Promise((resolve, reject) => {
		// 请求文件系统
		plus.io.requestFileSystem(
			plus.io.PUBLIC_DOCUMENTS,
			function(fs) {
				// 获取指定目录的目录条目
				fs.root.getDirectory(
					directoryPath, {
						create: false
					},
					function(dirEntry) {
						// 目录存在
						console.log(
							"systemCofig.js_checkAndCreateDirectory_目录已存在:",
							directoryPath
						);

						resolve(dirEntry);
						return
					},
					function(error) {
						// 目录不存在，创建目录
						if (error.code === 1) {
							// DOM Exception: NOT_FOUND_ERR (1)
							fs.root.getDirectory(
								directoryPath, {
									create: true
								},
								function(newDirEntry) {
									console.log(
										"systemCofig.js_checkAndCreateDirectory_目录创建成功:",
										newDirEntry.fullPath
									);

									resolve(newDirEntry);
								},
								function(error) {
									reject({
										...error,
										msg: "systemCofig.js_checkAndCreateDirectory__创建目录失败:",
									});
								}
							);
						} else {
							console.error(
								"systemCofig.js_checkAndCreateDirectory_获取目录失败111:",
								error.message
							);

							fs.root.getDirectory(
								directoryPath, {
									create: true
								},
								function(newDirEntry) {
									console.log(
										"systemCofig.js_checkAndCreateDirectory_目录创建成功:",
										newDirEntry.fullPath
									);

									resolve(newDirEntry);
								}
							);
						}
					}
				);
			},
			function(error) {
				reject({
					...error,
					msg: "systemCofig.js_checkAndCreateDirectory_请求文件系统失败:",
				});
			}
		);
	});
}

// 检查文件是否存在
export async function checkFileExists(directoryPath, fileName) {
	return new Promise((resolve, reject) => {
		//  请求文件系统
		plus.io.requestFileSystem(
			plus.io.PUBLIC_DOCUMENTS,
			function(fs) {
				// 获取指定目录的目录条目
				fs.root.getDirectory(
					directoryPath, {
						create: false
					},
					function(dirEntry) {
						// 尝试获取文件
						dirEntry.getFile(
							fileName, {
								create: false
							},
							function(fileEntry) {
								// 文件存在
								console.log("文件存在:", fileEntry.fullPath);

								resolve(fileEntry);
							},
							function(error) {
								// 文件不存在
								reject({
									...error,
									...FILE_ENUM.fileNotExist,

									// code: FILE_ENUM
									// msg: "checkFileExists_文件不存在",
								});
							}
						);
					},
					function(error) {
						console.error("获取目录失败:", error.message);
						reject({
							...error,
							...FILE_ENUM.getDirectoryError,
							// msg: "checkFileExists_获取目录失败",
						});
					}
				);
			},
			function(error) {
				console.error("请求文件系统失败:", error.message);
				reject({
					...error,
					...FILE_ENUM.fileSystemError,
					// msg: "checkFileExists_请求文件系统失败",
				});
			}
		);
	});
}

export const readFilesInDirectory = async (directoryPath) => {
	const promiseArr = [];

	return new Promise((resolve, reject) => {
		plus.io.requestFileSystem(
			plus.io.PRIVATE_DOC,
			function(fs) {
				fs.root.getDirectory(
					directoryPath, {
						create: false
					},
					function(dirEntry) {
						let directoryReader = dirEntry.createReader();
						directoryReader.readEntries(
							function(entries) {
								entries.forEach((entry) => {
									if (entry.isFile) {
										// 读取文件内容
										promiseArr.push(readFileContent(entry));
									} else if (entry.isDirectory) {
										// 递归读取子目录内容
										promiseArr.push(readFilesInDirectory(entry
											.fullPath));
									}
								});

								Promise.all(promiseArr)
									.then((results) => {
										// 扁平化结果数组，因为子目录可能返回一个包含多个文件内容的数组
										const flatResults = results.flat(Infinity);
										resolve(flatResults);
									})
									.catch((error) => {
										console.log("readFilesInDirectory:", error);
										reject({
											...FILE_ENUM.getFileError,
											message: "读取文件内容失败:" + error
												.message,
										});
									});
							},
							function(error) {
								console.log("readFilesInDirectory:", error);
								reject({
									...FILE_ENUM.readDirectoryError,
									message: "读取目录条目失败:" + error.message,
								});
							}
						);
					},
					function(error) {
						console.log("readFilesInDirectory:", error, directoryPath);
						reject({
							...FILE_ENUM.getDirectoryError,
							message: "获取目录失败:" + error.message,
						});
					}
				);
			},
			function(error) {
				console.log("readFilesInDirectory:", error);
				reject({
					...FILE_ENUM.fileSystemError,
					message: "请求文件系统失败:" + error.message,
				});
			}
		);
	});
};


// 读取【单个文件】内容
export async function readFileContent(fileEntry) {
	return new Promise((resolve, reject) => {
		// 创建FileReader对象
		const reader = new plus.io.FileReader();
		// 读取文件
		reader.onload = function(e) {
			resolve(e.target.result);
		};
		reader.onerror = function(e) {
			console.error(
				"systemCofig.js_readFileContent_读取文件失败:",
				e.target.error
			);

			reject({
				// msg: "systemCofig.js_readFileContent_读取文件失败:",
				...e.target.error,
				...FILE_ENUM.readFileError,
			});
		};
		// 以文本方式读取文件
		reader.readAsText(fileEntry);
	});
}

/**
 * 写入文件
 * @param {*} directoryPath
 * @param {*} fileName
 * @param {*} fileContent  // 只能是字符串内容
 * @returns
 */
export function createFileWithPlusIO(directoryPath, fileName, fileContent) {
	return new Promise((resolve, reject) => {
		// 请求文件系统
		plus.io.requestFileSystem(
			plus.io.PUBLIC_DOCUMENTS,
			function(fs) {
				// 获取或创建目录
				fs.root.getDirectory(
					directoryPath, {
						create: true
					},
					function(dirEntry) {
						// 创建文件
						dirEntry.getFile(
							fileName, {
								create: true
							},
							function(fileEntry) {
								// 写入文件
								fileEntry.createWriter(
									function(fileWriter) {
										fileWriter.onwriteend = function() {
											resolve(fileContent);
										};
										fileWriter.onerror = function(error) {
											console.log(
												"createFileWithPlusIO_文件创建或写入失败:",
												error
											);
											reject({
												...error,
												...FILE_ENUM.writeFileError,
											});
										};

										// 向文件中写入数据
										fileWriter.write(fileContent);
									},
									function(error) {
										console.log(
											"createFileWithPlusIO_创建文件写入器失败:",
											error
										);

										reject({
											...error,
											...FILE_ENUM.createFileError,
										});
									}
								);
							},
							function(error) {
								console.log("createFileWithPlusIO_获取文件失败:", error);

								reject({
									...error,
									...FILE_ENUM.getFileError,
								});
							}
						);
					},
					function(error) {
						console.log("createFileWithPlusIO_获取目录失败:", error);

						reject({
							...error,
							...FILE_ENUM.getDirectoryError,
						});
					}
				);
			},
			function(error) {
				reject({
					...error,
					...FILE_ENUM.fileSystemError,

					msg: "createFileWithPlusIO_请求文件系统失败:",
				});
			}
		);
	});
}

// 加密方法
export function setSm2(data) {
	const sm2 = require("sm-crypto").sm2; // 获取sm2对象
	const cipherMode = 1; // 选择加密策略，1 - C1C3C2，0 - C1C2C3，默认为1
	const sysPublicKey =
		"042580b43bad40cc813a032ef3a4c3c38fc58796e0684dd9b5087195a305f4241f9bbefcc92a10e7296ffc167d22a921c164b8cbbbdbcf91ddc3f15202b993f03b"; // 系统后台公钥
	if (data) {
		return sm2.doEncrypt(JSON.stringify(data), sysPublicKey, cipherMode);
	} else {
		return null;
	}
}



// 获取用户数据
export function getUserList() {
	return new Promise((resolve, reject) => {
		try {
			const value = uni.getStorageSync("user_data");
			if (value) {
				resolve(eval(value));
			} else {
				uni.getStorage({
					key: "user_data",
					success: function(res) {
						resolve(eval(value));
					},
				});
			}
		} catch (e) {
			reject(e)
		}
	});
}

export function zipCompress(sourceDir, zipPath) {
  return new Promise((resolve, reject) => {
    plus.zip.compress(
      plus.io.convertLocalFileSystemURL(sourceDir),
      plus.io.convertLocalFileSystemURL(zipPath),
      {
        recursive: true,
        overwrite: true,
      },
      () => resolve(zipPath),
      (error) => reject(`压缩失败: ${error.message}`)
    );
  });
}