interface NetRequestParams {
  url: string
  method: string
  queryParams?: any
  payload?: any
  additionalHeaders?: any
}

/**
 * 记录响应详情并返回响应日志对象。
 * @param response - 响应对象。
 * @param method - 请求使用的HTTP方法。
 * @param headers - 请求头。
 * @param requestBody - 请求体。
 * @param responseBody - 响应体。
 * @returns 响应日志对象。
 */
const logResponse = (
  response: Response,
  method: string,
  headers: any,
  requestBody: any,
  responseBody: any
) => {
  const responseLog = {
    ok: response.ok,
    status: response.status,
    statusText: response.statusText,
    url: response.url,
    method: method,
    requestHeaders: headers,
    responseHeaders: response.headers,
    requestBody,
    responseBody,
  }
  console.log("🚀 ~ responseLog:", JSON.stringify(responseLog, null, 2))
  return responseLog
}

/**
 * 发送网络请求并返回一个解析为响应数据的Promise。
 * @param url - 要发送请求的URL。
 * @param method - 请求使用的HTTP方法。
 * @param queryParams - 要包含在URL中的查询参数。
 * @param payload - 请求的有效负载数据。
 * @param additionalHeaders - 要包含在请求中的附加头。
 * @returns 一个解析为响应数据的Promise。
 * @throws 如果网络响应不成功或存在解析错误，则抛出错误。
 */
const netTool = async <T = any>({
  url,
  method,
  queryParams,
  payload,
  additionalHeaders,
}: NetRequestParams): Promise<T> => {
  // 拼接完整的URL
  let fullUrl = url
  if (queryParams) {
    if (typeof queryParams === "string") {
      fullUrl = `${url}?${queryParams}`
    } else {
      const queryString = new URLSearchParams(queryParams).toString()
      if (queryString) fullUrl = `${url}?${queryString}`
    }
  }

  // 设置请求头
  const headers = {
    "Content-Type": "application/json",
    ...additionalHeaders,
  }

  // 发送请求
  const res = await fetch(fullUrl, {
    method,
    body: JSON.stringify(payload),
    headers,
  })
  // 获取响应数据
  let resData: any = null
  let resText: string = ""

  try {
    resText = await res.text()
    resData = JSON.parse(resText)
  } catch {
    /* empty */
  }

  // 记录响应
  logResponse(res, method, headers, payload, resData || resText)
  if (!res.ok) {
    if (resData?.msg) {
      throw new Error(resData.msg)
    }
    if (resText) {
      throw new Error(resText)
    }
    throw new Error("网络响应异常")
  }
  // http 错误码正常，但解析异常
  if (!resData) {
    throw new Error("解析响应数据异常")
  }
  return resData as T
}

/**
 * 发送GET请求并返回一个解析为响应数据的Promise。
 *
 * @param url - 要发送请求的URL。
 * @param queryParams - 要包含在URL中的查询参数。
 * @param additionalHeaders - 要包含在请求中的附加头。
 * @returns 一个解析为响应数据的Promise。
 */
netTool.get = <T = any>(
  url: string,
  queryParams?: any,
  additionalHeaders?: any
): Promise<T> => netTool({ url, method: "get", queryParams, additionalHeaders })

/**
 * 发送POST请求并返回一个解析为响应数据的Promise。
 *
 * @param url - 要发送请求的URL。
 * @param payload - 请求的有效负载数据。
 * @param queryParams - 要包含在URL中的查询参数。
 * @param additionalHeaders - 要包含在请求中的附加头。
 * @returns 一个解析为响应数据的Promise。
 */
netTool.post = <T = any>(
  url: string,
  payload?: any,
  queryParams?: any,
  additionalHeaders?: any
): Promise<T> =>
  netTool({ url, method: "post", payload, queryParams, additionalHeaders })

/**
 * 发送PUT请求并返回一个解析为响应数据的Promise。
 *
 * @param url - 要发送请求的URL。
 * @param payload - 请求的有效负载数据。
 * @param queryParams - 要包含在URL中的查询参数。
 * @param additionalHeaders - 要包含在请求中的附加头。
 * @returns 一个解析为响应数据的Promise。
 */
netTool.put = <T = any>(
  url: string,
  payload: any,
  queryParams?: any,
  additionalHeaders?: any
): Promise<T> =>
  netTool({ url, method: "put", payload, queryParams, additionalHeaders })

/**
 * 发送DELETE请求并返回一个解析为响应数据的Promise。
 *
 * @param url - 要发送请求的URL。
 * @param payload - 请求的有效负载数据。
 * @param queryParams - 要包含在URL中的查询参数。
 * @param additionalHeaders - 要包含在请求中的附加头。
 * @returns 一个解析为响应数据的Promise。
 */
netTool.del = <T = any>(
  url: string,
  payload: any,
  queryParams?: any,
  additionalHeaders?: any
): Promise<T> =>
  netTool({ url, method: "delete", payload, queryParams, additionalHeaders })

/**
 * 发送PATCH请求并返回一个解析为响应数据的Promise。
 *
 * @param url - 要发送请求的URL。
 * @param payload - 请求的有效负载数据。
 * @param queryParams - 要包含在URL中的查询参数。
 * @param additionalHeaders - 要包含在请求中的附加头。
 * @returns 一个解析为响应数据的Promise。
 */
netTool.patch = <T = any>(
  url: string,
  payload: any,
  queryParams?: any,
  additionalHeaders?: any
): Promise<T> =>
  netTool({ url, method: "patch", payload, queryParams, additionalHeaders })

/**
 * 创建一个表示400 Bad Request的响应对象。
 *
 * @param msg - 错误消息。
 * @param requestId - 请求ID。
 * @returns 一个表示400 Bad Request的响应对象。
 */
netTool.badRequest = (msg: string, requestId?: string) =>
  Response.json({ code: 400, msg, requestId }, { status: 400 })

/**
 * 创建一个表示404 Not Found的响应对象。
 *
 * @param msg - 错误消息。
 * @param requestId - 请求ID。
 * @returns 一个表示404 Not Found的响应对象。
 */
netTool.notFound = (msg: string, requestId?: string) =>
  Response.json({ code: 404, msg, requestId }, { status: 404 })

/**
 * 创建一个表示500 Internal Server Error的响应对象。
 *
 * @param msg - 错误消息。
 * @param data - 错误数据。
 * @param requestId - 请求ID。
 * @returns 一个表示500 Internal Server Error的响应对象。
 */
netTool.serverError = (msg: string, data?: any, requestId?: string) =>
  Response.json({ code: 500, msg, data, requestId }, { status: 500 })

/**
 * 创建一个表示200 OK的响应对象。
 *
 * @param data - 响应数据。
 * @param requestId - 请求ID。
 * @returns 一个表示200 OK的响应对象。
 */
netTool.ok = (data?: any, requestId?: string) =>
  Response.json({ code: 0, msg: "success", data, requestId })

export default netTool