import { http } from '@kit.NetworkKit';
import { BusinessError, request, systemDateTime } from '@kit.BasicServicesKit';
import { buffer, util } from '@kit.ArkTS';
import { cryptoFramework } from '@kit.CryptoArchitectureKit';
import { Core, DLogger } from 'core';

const TAG = 'RequestClient'

export interface HttpResponse<T> {
  data: T;
  status: number;
  error: Error | undefined
}

export type HttpPromise<T> = Promise<HttpResponse<T>>;

export class RequestClient {
  static getBaseUrl(): string {
    return Core.getHost()
  }

  static getRequestUrl(path: string, baseUrl?: string): string {
    return `${baseUrl ?? RequestClient.getBaseUrl()}${path}`
  }

  static async request(path: string, method: http.RequestMethod, requestData?: Map<string, Object>,
    baseUrl?: string): Promise<HttpPromise<object>> {
    const httpRequest = http.createHttp()
    const token = ''
    const url = RequestClient.getRequestUrl(path, baseUrl)
    const uuid = util.generateRandomUUID(false)
    const headers: Record<string, string | undefined> = {
      'Content-Type': 'application/json',
      'Accept': 'application/json',
      'X-Auth-Token': token,
      'X-Trace-Id': uuid,
      // 'User-Agent': encodeURIComponent("Mozilla/5.0 (Linux; Android 12; BRA-AL00 Build/HUAWEIBRA-AL00; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/114.0.5735.196 Mobile Safari/537.36"),
      'agent': encodeURIComponent("light/4.113.0/android/BRA-AL00/12/BRA-AL00")
    }

    DLogger.debug(`http request -> ${method}:${url}\nheaders -> ${JSON.stringify(headers)}\ndata -> ${JSON.stringify(requestData)}`)
    let commonParams = await RequestClient.getCommonParams()
    requestData?.forEach((value, key) => {
      commonParams.set(key, value)
    })
    const record = RequestClient.mapToRecord(commonParams)
    DLogger.debug(`http request record -> ${JSON.stringify(record)}`)

    return httpRequest.request(url, {
      method: method,
      header: headers,
      expectDataType: http.HttpDataType.STRING,
      extraData: record
    }).then((httpResponse: http.HttpResponse) => {
      console.info('Result type:' + httpResponse.resultType); // 验证实际类型

      DLogger.debug(`http response -> ${method}:${url}\n${JSON.stringify(httpResponse)}`)
      if (httpResponse.responseCode === http.ResponseCode.OK) {
        return Promise.resolve(JSON.parse(httpResponse.result.toString()))
      } else {
        return Promise.reject(httpResponse.responseCode)
      }
    }).catch((err: BusinessError) => {
      DLogger.debug(`http error:${JSON.stringify(err)}`);
      return Promise.reject(err)
    }).finally(() => {
      httpRequest.destroy()
    })
  }

  static get(path: string, requestData?: Map<string, Object>,
    baseUrl?: string): Promise<HttpPromise<object>> {
    return RequestClient.request(path, http.RequestMethod.GET, requestData, baseUrl)
  }

  static post(path: string, requestData?: Map<string, Object>,
    baseUrl?: string): Promise<HttpPromise<object>> {
    return RequestClient.request(path, http.RequestMethod.POST, requestData, baseUrl)
  }

  static mapToRecord<K extends string, V>(map: Map<K, V>): Record<K, V> {
    const result: Record<K, V> = {} as Record<K, V>;
    map.forEach((value, key) => {
      result[key] = value;
    });
    return result;
  }

  static async getCommonParams(): Promise<Map<string, Object>> {
    const map = new Map<string, Object>()
    map.set("app_id", "light")
    map.set("timestamp", RequestClient.getCurrentStamp().toString())
    map.set("lang", "zh-Hans")
    map.set("device", "mobile")
    map.set("os", "Android")
    map.set("platform", "light")
    map.set("sdk_version", "2.2.10")
    map.set("version", "88.4.3")
    map.set("terminal", "app")

    // map.set("offset", "0")
    // map.set("limit", "5")
    map.set("system_model", "BRA-AL00")
    return map
  }

  static getCurrentStamp(): number {
    let time = 0
    try {
      time = systemDateTime.getTime(true) / 1000000
    } catch (e) {
      let error = e as BusinessError;
      DLogger.error(`Failed to get time. message: ${error.message}, code: ${error.code}`);
    }
    return time
  }
}