import VirtualDirectory, { VirtualFile } from "@/class/VirtualDirectory";
import {
	getOption,
	getResponse,
	miaoFetchConfig,
	deleteOption,
	uploadOption,
	queryOption,
	renameOption,
	cutOption,
	mkdirOption,
	getFileOption
} from "@/types/fetch";
import Config from "@/config";
import axios, { AxiosRequestConfig, AxiosResponse } from "axios";

export const useMiaoFetch = (option?: miaoFetchConfig) => {
	const retry = option?.retry ?? 0;
	const controller = new AbortController();
	let flag = true;
	return {
		miaoFetch: async (config: AxiosRequestConfig<any>): Promise<AxiosResponse<any, any>> => {
			let counter = 0;
			let response: any;
			let errList = [];
			while (flag && counter <= retry) {
				try {
					response = await axios({
						...config,
						signal: controller.signal
					});
					return response;
				} catch (_e) {
					errList.push(_e);
					counter += 1;
				}
			}
			throw errList;
		},
		/**
		 * 强制终止miaoFetch
		 */
		abortMiaoFetch: () => {
			flag = false;
			controller.abort();
		}
	};
};

const miaoFetchApi = {
	/**
	 * 获取对应文件夹下的数据
	 */
	async get(vDirectory: VirtualDirectory, option?: getOption): Promise<getResponse> {
		const { baseUrl, api } = Config;
		const url = `${baseUrl}${api.get}${vDirectory.path}`;
		const retry = option?.retry ?? 0;

		const { miaoFetch } = useMiaoFetch({
			retry
		});
		const response = await miaoFetch({
			url
		});
		return response.data;
	},

	/**
	 * 获取对应文件下的数据
	 */
	getFile(vFile: VirtualFile, option?: getFileOption) {
		// const { baseUrl, api } = Config
		const url = vFile.url;
		const retry = option?.retry ?? 0;
		const axiosOption = option?.axiosOption ?? {};

		const { miaoFetch, abortMiaoFetch: abort } = useMiaoFetch({
			retry
		});
		const response = miaoFetch({
			url,
			responseType: "arraybuffer",
			onDownloadProgress(progressEvent) {
				option && option.onProcess && option.onProcess(progressEvent.total ? progressEvent.loaded / progressEvent.total : -1);
			},
			...axiosOption
		});
		return {
			response: new Promise<Uint8Array>(async resolve => {
				resolve(new Uint8Array((await response).data));
			}),
			abort
		};
	},

	/**
	 * 上传单个文件到对应文件夹, 后续要将data类型改成buffer以支持分片上传
	 * 正常上传文件请使用uploadQueue
	 */
	upload(data: File, targetVDir: VirtualDirectory, option?: uploadOption) {
		const { baseUrl, api } = Config;
		const url = `${baseUrl}${api.upload}${targetVDir.path}`;
		const retry = option?.retry ?? 0;
		const { miaoFetch, abortMiaoFetch } = useMiaoFetch({
			retry
		});
		const sizeTotal = data.size;

		const opType = option?.type ?? "write";

		const formData = new FormData();

		formData.append("file", data);
		// 必须这样传，不然中文乱码
		formData.append("fileName", data.name);
		formData.append("operateType", opType);

		return {
			abort: () => abortMiaoFetch(),
			response: new Promise<{
				message: "success" | "failed";
				error?: string;
			}>(async resolve => {
				const response = await miaoFetch({
					url,
					method: "post",
					data: formData,
					onUploadProgress(progressEvent) {
						option && option.onProcess && option.onProcess(progressEvent.loaded / sizeTotal);
					}
				});
				resolve(response.data);
			})
		};
	},

	/**
	 * 在目标文件夹下创建新的文件夹
	 */
	mkdir(targetVDir: VirtualDirectory, newFolderName: string, option?: mkdirOption) {
		const { baseUrl, api } = Config;
		const url = `${baseUrl}${api.mkdir}${targetVDir.path}`;
		const { miaoFetch } = useMiaoFetch({
			retry: option?.retry ?? 0
		});

		return new Promise<{
			message: "success" | "failed";
			error?: string;
		}>(async resolve => {
			const response = await miaoFetch({
				url,
				method: "post",
				data: {
					folderName: newFolderName
				}
			});
			resolve(response.data);
		});
	},
	/**
	 * 在目标文件夹下创建新的空文件，实际上是通过upload空文件实现
	 */
	mkFile(targetVDir: VirtualDirectory, newFileName: string, option?: uploadOption) {
		const emptyBlob = new Blob([]);
		const emptyFile = new File([emptyBlob], newFileName, {
			type: "text/plain"
		});
		return this.upload(emptyFile, targetVDir, option);
	},

	/**
	 * 删除对应的文件或文件夹，若为文件夹会递归删除
	 */
	delete(target: VirtualFile | VirtualDirectory, option?: deleteOption) {
		const { baseUrl, api } = Config;
		const url = `${baseUrl}${api.delete}${target.path}`;
		const retry = option?.retry ?? 0;
		const { miaoFetch } = useMiaoFetch({
			retry
		});

		return {
			response: new Promise<{
				eventId: number;
			}>(async resolve => {
				const response = await miaoFetch({
					url,
					method: "post"
				});
				resolve(response.data);
			})
		};
	},
	/**
	 * 重命名对应的文件或文件夹
	 */
	rename(target: VirtualFile | VirtualDirectory, newName: string, option?: renameOption) {
		const { baseUrl, api } = Config;
		const url = `${baseUrl}${api.rename}${target.path}`;
		const retry = option?.retry ?? 0;
		const { miaoFetch } = useMiaoFetch({
			retry
		});

		return {
			response: new Promise<{
				eventId: number;
			}>(async resolve => {
				const response = await miaoFetch({
					url,
					method: "post",
					data: { newName }
				});
				resolve(response.data);
			})
		};
	},
	/**
	 * 剪切文件或文件夹
	 */
	cut(target: VirtualFile | VirtualDirectory, to: VirtualDirectory, option?: cutOption) {
		const newPath = to.path;
		const { baseUrl, api } = Config;
		const url = `${baseUrl}${api.cut}${target.path}`;
		const retry = option?.retry ?? 0;
		const { miaoFetch } = useMiaoFetch({
			retry
		});
		return {
			response: new Promise<{
				eventId: number;
			}>(async resolve => {
				const response = await miaoFetch({
					url,
					method: "post",
					data: { newPath }
				});
				resolve(response.data);
			})
		};
	},

	/**
	 * 查询服务端操作事件的进展
	 */
	query(eventId: number, option?: queryOption) {
		const { baseUrl, api } = Config;
		const url = `${baseUrl}${api.query}`;
		const retry = option?.retry ?? 0;
		const { miaoFetch } = useMiaoFetch({
			retry
		});
		return {
			response: new Promise<{
				status: "process" | "success" | "failed";
				error?: unknown;
			}>(async resolve => {
				const response = await miaoFetch({
					url,
					method: "get",
					params: {
						id: eventId
					}
				});
				resolve(response.data);
			})
		};
	}
};

export default function useMiaoFetchApi() {
	return miaoFetchApi;
}