/**
 * 这里写的是业务相关的：
 * * 请求数据处理函数。
 * * 自定义请求模块。
 * * 自定义错误报告处理函数。
 */

import { 
  RequestCoreInstance, RequestOptions, RequestApiError, RequestApiResult, type RequestApiErrorType,
  defaultResponseDataGetErrorInfo, defaultResponseDataHandlerCatch,
  RequestResponse,
  appendGetUrlParams, 
  appendPostParams,
  type RequestApiInfoStruct,
  WebFetchImplementer,
} from "@imengyu/imengyu-utils";
import type { DataModel, NewDataModel } from "@imengyu/js-request-transform";
import { StringUtils } from "@imengyu/imengyu-utils";

const ApiCofig = {
  serverDev: '/api',
  serverProd: '/api',
  mainBodyId: 1,
}

/**
 * 不报告错误的 code
 */
const notReportErrorCode = [401] as number[];
const notReportMessages = [
  /请授权绑定手机号/g,
] as RegExp[];
function matchNotReportMessage(str: string) {
  for (let i = 0; i < notReportMessages.length; i++) {
    if (notReportMessages[i]?.test(str))
      return true;
  }
  return false;
}

//请求拦截器
function requestInceptor(url: string, req: RequestOptions) {
  if (req.method == 'GET') {
    //追加GET参数
    url = appendGetUrlParams(url, 'main_body_id', ApiCofig.mainBodyId);
  } else {
    req.data = appendPostParams(req.data,'main_body_id', ApiCofig.mainBodyId);
  } 
  return { newUrl: url, newReq: req };
}
//响应数据处理函数
function responseDataHandler<T extends DataModel>(response: RequestResponse, req: RequestOptions, resultModelClass: NewDataModel | undefined, instance: RequestCoreInstance<T>, apiInfo: RequestApiInfoStruct): Promise<RequestApiResult<T>> {
  return new Promise<RequestApiResult<T>>((resolve, reject) => {
    const method = req.method || 'GET';
    response.json().then((json) => {
      if (response.ok) {
        if (!json) {
          reject(new RequestApiError(
            'businessError',
            '后端未返回数据',
            '',
            response.status,
            null,
            null,
            response.headers,
            apiInfo
          ));
          return;
        }

        //code == 0 错误
        if (json.code === 0) {
          handleError();
          return;
        }

        //处理后端的数据
        let message = '未知错误';
        let data = {} as any;

        //后端返回格式不统一，所以在这里处理格式
        if (typeof json.data === 'object') {
          data = json.data;
          message = json.data?.msg || response.statusText;
        }
        else {
          //否则返回上层对象
          data = json;
          message = json.msg || response.statusText;
        }

        resolve(new RequestApiResult(
          resultModelClass ?? instance.config.modelClassCreator,
          json?.code || response.status,
          message,
          data,
          json,
          response.headers,
          apiInfo
        ));
      }
      else {
        handleError();
      }

      function handleError() {
        let errType : RequestApiErrorType = 'unknow';
        let errString = '';
        let errCodeStr = '';

        if (typeof json.message === 'string') 
          errString = json.message;
        if (typeof json.msg === 'string') 
          errString += json.msg;

        if (StringUtils.isStringAllEnglish(errString))
          errString = '服务器返回：' + errString;

        //错误处理
        if (errString) {
          //如果后端有返回错误信息，则收集错误信息并返回
          errType = 'businessError';
          if (typeof json.data === 'object' && json.data?.errmsg) {
            errString += '\n' + json.data.errmsg;
          }
          if (typeof json.errors === 'object') {
            for (const key in json.errors) {
              if (Object.prototype.hasOwnProperty.call(json.errors, key)) {
                errString += '\n' + json.errors[key];
              }
            }
          }
        } else {
          const res = defaultResponseDataGetErrorInfo(response, json);
          errType = res.errType;
          errString = res.errString;
          errCodeStr = res.errCodeStr;
        }

        reject(new RequestApiError(
          errType,
          errString,
          errCodeStr,
          response.status,
          null,
          null,
          response.headers,
          apiInfo
        ));
      }
    }).catch((err) => {
      //错误统一处理
      defaultResponseDataHandlerCatch(method, req, response, null, err, apiInfo, response.url, reject, instance);
    });
  });
}
//错误报告处理
function responseErrReoprtInceptor<T extends DataModel>(instance: RequestCoreInstance<T>, response: RequestApiError) {
  return (
    (response.errorType !== 'businessError' && response.errorType !== 'networkError') ||
    notReportErrorCode.indexOf(response.code) >= 0 ||
    matchNotReportMessage(response.errorMessage) === true
  );
}

//错误报告处理
export function reportError<T extends DataModel>(instance: RequestCoreInstance<T>, response: RequestApiError | Error) {
  
}

/**
 * App服务请求模块
 */
export class AppServerRequestModule<T extends DataModel> extends RequestCoreInstance<T> {
  constructor() {
    super(WebFetchImplementer);
    this.config.baseUrl = 'https://mn.wenlvti.net/api',//ApiCofig.serverProd;
    this.config.errCodes = []; //
    this.config.requestInceptor = requestInceptor;
    this.config.responseDataHandler = responseDataHandler;
    this.config.responseErrReoprtInceptor = responseErrReoprtInceptor;
    this.config.reportError = reportError;
  }
}