import isEmpty from 'lodash/isEmpty';
import type { AxiosResponse } from 'axios';
import type { Service } from 'ahooks/lib/useRequest/src/types';
import type { IRequestConfig, IResponse } from './types';
import { packRequest } from './pack-request';
import { getStandardData } from './get-standard-data';
import processPostData from './process-post-data';
import processGetParams from './process-get-params';

export function getRequestService<
  IResponseData = unknown,
  IRequestParam = unknown,
  IFormatResult = IResponseData,
  IFormatParam = IRequestParam,
>(
  requestConfig?: IRequestConfig<
    IResponseData,
    IRequestParam,
    IFormatResult,
    IFormatParam
  >,
) {
  if (!requestConfig) return undefined;

  const {
    service: serviceProps,
    method: methodProps,
    data: dataProps,
    formatParam,
    formatResult: formatResultProps,
    headers,
  } = requestConfig;
  const contentType = headers?.['content-type'] as string | undefined;
  const method = methodProps?.toLocaleUpperCase() || 'GET';
  const formatResult = formatResultProps || requestConfig.resultFormatter;

  /**
   * 兼容历史逻辑，该逻辑未来会删除
   */
  const compatibleOldData = (res: AxiosResponse) => {
    if (isEmpty(res)) {
      return res;
    }
    if (typeof formatResult === 'function') {
      // @ts-ignore 历史兼容代码类型不匹配，忽略校验
      return formatResult(res);
    }
    if (!isEmpty(res?.data)) {
      return res?.data;
    }
  };

  const service: Service<IFormatResult, IFormatParam[]> = async (params) => {
    if (serviceProps) {
      const response = await serviceProps(params);
      /**
       * start compatible
       * 兼容历史逻辑，该逻辑未来会删除
       * 当用户自定义service方法时，用户需要返回组件能消费的数据结构，以下逻辑是为了兼容历史代码
       */
      const responseKeys = Object.keys(response as AxiosResponse);
      if (
        responseKeys.includes('request') &&
        responseKeys.includes('status') &&
        responseKeys.includes('headers') &&
        responseKeys.includes('config')
      ) {
        return compatibleOldData(response as AxiosResponse) as IFormatResult;
      }
      /** end compatible */
      return response as IFormatResult;
    }

    const processedParams = processGetParams({
      method,
      runParams: params,
      params: requestConfig.params,
      formatParam,
    });

    const processedData = processPostData({
      contentType,
      method,
      runParams: params,
      data: dataProps ?? requestConfig.params, // 兼容低码组件POST请求传递参数时没有data的情况
      formatParam,
    });

    const res = await packRequest<IResponse<IResponseData>>({
      ...requestConfig,
      params: processedParams,
      data: processedData,
    });
    return getStandardData<IResponseData, IFormatResult>(res, formatResult);
  };

  return service;
}