/**
 * IHttpListener接口定義了HTTP請求完成后的回調方法。
 * 實現此接口的監聽器將被用于處理HTTP請求的成功和失敗事件。
 */
export interface IHttpListener {
  /**
   * 當HTTP請求成功完成時調用此方法。
   * @param result - 請求成功的結果，通常是一個字符串形式的響應數據。
   * 根據實際需求，這個結果可能需要進一步解析以獲取結構化的數據。
   */
  onSuccess(result: string): void;

  /**
   * 當HTTP請求失敗時調用此方法。
   * 失敗的原因可能包括網絡問題、服務器錯誤、請求超時等。
   * 實現此方法的監聽器應該能夠處理這些錯誤情況，例如通過顯示錯誤消息或執行回退操作。
   */
  onFailure(error: any): void;
}

/**
 * IDataListener接口定義了處理數據成功和失敗事件的監聽器方法。
 * 該接口用于在數據操作（如讀取、寫入、提交等）完成后進行回調。
 * 泛型T表示數據的類型，可以是任何類型，使得監聽器能夠處理特定類型的數據。
 */
export interface IDataListener<T> {

  /**
   * 當數據操作成功完成時調用此方法。
   * 該方法接收操作結果中的數據作為參數，可以用于更新UI、存儲數據或其他操作。
   * @param t - 數據操作成功后返回的數據。
   */
  onSuccess(t: T): void;

  /**
   * 當數據操作失敗時調用此方法。
   * 該方法同樣接收可能在操作中返回的數據，可以用來了解失敗的原因或進行錯誤處理。
   * @param t - 數據操作失敗時返回的數據或錯誤信息。
   */
  onFailure(t: any): void;

}

import{ IHttpListener } from'./IHttpListener';
import{ IHttpRequest } from'./IHttpRequest';

/**
 * HttpTask類用于封裝HTTP請求任務，提供執行請求和處理響應的功能。
 * 泛型T用于表示請求數據的類型。
 */
export class HttpTask<T> {
  // IHttpRequest類型的私有成員變量，用于發送HTTP請求和接收響應
  private iHttpRequest: IHttpRequest;
  // IHttpListener類型的私有成員變量，用于監聽HTTP請求的響應事件
  private iHttpListener: IHttpListener;

  /**
   * 構造函數接收請求的URL、請求數據、IHttpRequest實例和IHttpListener實例。
   * 通過這些參數初始化HttpTask實例，準備發送HTTP請求。
   * @param url - 請求的目標URL。
   * @param requestData - 要發送的請求數據，可以是任何類型，將被轉換為JSON格式。
   * @param header - 請求頭。
   * @param body - 請求體。
   * @param iHttpRequest - 實現IHttpRequest接口的請求對象，用于設置請求方法、頭信息等。
   * @param iHttpListener - 實現IHttpListener接口的監聽器對象，用于處理請求的響應。
   */
  constructor(url: string, header: Record<string, string>, requestData: T, iHttpRequest: IHttpRequest,
              iHttpListener: IHttpListener) {
    // 初始化請求對象
    this.iHttpRequest = iHttpRequest;
    // 初始化監聽器對象
    this.iHttpListener = iHttpListener;

    // 設置請求的目標URL
    this.iHttpRequest.setUrl(url);
    // 將監聽器對象綁定到請求對象，以便在請求完成時接收響應
    this.iHttpRequest.setListener(iHttpListener);

    if(header != null) {
      this.iHttpRequest.setHeader(header)
    }

    // 如果提供了請求數據
    if(requestData != null) {
      // 將請求數據轉換為JSON字符串格式

      let requestParams: string = JSON.stringify(requestData);
      // 打印請求參數，便于調試
      console.log("HttpTask:" + "  requestParams:" + requestParams);
      // 設置請求參數，這些參數將在請求發送時附加到請求體中
      this.iHttpRequest.setParams(requestParams);
    }
  }

  static encodeParams(params: { [key: string]: any }): string {
    let result = Object.keys(params)
      .map(key => encodeURIComponent(key) + '=' + encodeURIComponent(params[key]))
      .join('&');
    returnresult;
  }

  /**
   * 異步執行HTTP請求的方法。
   * 該方法通過調用iHttpRequest的execute方法發送請求，并等待響應。
   * 當execute方法返回的Promise被解決時，該方法完成。
   * @returns 返回一個Promise<void>，表示異步操作的完成。
   */
  async run(): Promise<void> {
    // 調用請求對象的execute方法來發送請求，并等待響應
    await this.iHttpRequest.execute();
  }
}

importhttp from'@ohos.net.http'; // 引入OhOS的http模塊
import{ IHttpListener } from'./IHttpListener';
import{ IHttpRequest } from'./IHttpRequest';

/**
 * JsonHttpRequest類實現了IHttpRequest接口，用于發送JSON格式的HTTP請求。
 * 該類使用OhOS的http模塊創建和管理HTTP請求，并處理請求結果。
 */
export class JsonHttpRequest implementsIHttpRequest {
  private url: string = '';
  private params: string = '';
  private iHttpListener: IHttpListener | null = null; // 存儲請求的監聽器
  private httpRequest: http.HttpRequest | null = null; // 存儲OhOS的HttpRequest對象

  /**
   * 構造函數。
   */
  constructor() {
    this.httpRequest = http.createHttp(); // 初始化OhOS的HttpRequest對象
  }

  /**
   * 設置請求的URL。
   * @param url - 要請求的資源的URL字符串。
   */
  setUrl(url: string): void {
    this.url = url;
  }

  /**
   * 設置請求的參數。
   * @param params - 要發送的請求參數。
   */
  setParams(params: string): void {
    this.params = params;
  }

  /**
   * 設置請求的監聽器。
   * @param iHttpListener - 實現IHttpListener接口的監聽器對象。
   */
  setListener(iHttpListener: IHttpListener): void {
    this.iHttpListener = iHttpListener;
  }

  /**
   * 異步執行HTTP請求的方法。
   */
  asyncexecute(): Promise<void> {
    try{
      if(!this.url) {
        throw new Error('URL is not set.');
      }
      if(!this.iHttpListener) {
        throw new Error('HTTP Listener is not set.');
      }

      console.log('JsonHttpRequest: Sending request to:', this.url);

      // 使用GET方法發送請求，并將params作為請求體發送
      this.httpRequest.request(this.url, {
        method: http.RequestMethod.GET,
        extraData: this.params
      }, (err, data) => {
        if(err) {
          // 請求失敗，調用監聽器的onFailure方法
          console.error('JsonHttpRequest: Request failed:', err);
          this.iHttpListener.onFailure(err);
        } else{
          // 請求成功，調用監聽器的onSuccess方法
          console.log('JsonHttpRequest: Request successful:', data.result);
          this.iHttpListener.onSuccess(data.result.toString());
        }
        // 請求完成后，主動銷毀請求對象以釋放資源
        this.httpRequest.destroy();
      });
    } catch(error) {
      console.error('JsonHttpRequest: An error occurred:', error);
      if(this.iHttpListener) {
        this.iHttpListener.onFailure(error);
      }
    }
  }
}

import{ IDataListener } from'./IDataListener';
import{ IHttpListener } from'./IHttpListener';

/**
 * JsonHttpListener類實現了IHttpListener接口，用于處理HTTP請求的響應。
 * 它將HTTP響應結果轉換為泛型類型T的對象，并將其傳遞給IDataListener接口的實現。
 * 泛型T允許處理各種類型的數據，使得監聽器能夠靈活地處理不同格式的響應。
 */
export class JsonHttpListener<T> implements IHttpListener {
  // 存儲IDataListener接口的實現，用于回調數據給調用者
  private iDataListener: IDataListener<T>;

  /**
   * 構造函數接收一個IDataListener接口的實現。
   * @param iDataListener - 實現IDataListener接口的監聽器對象。
   */
  constructor(iDataListener: IDataListener<T>) {
    this.iDataListener = iDataListener;
  }

  /**
   * 當HTTP請求成功時調用此方法。
   * 該方法接收原始的響應字符串，并嘗試將其解析為泛型類型T的對象。
   * 解析成功后，調用IDataListener的onSuccess方法，并將解析后的對象作為參數傳遞。
   * @param result - HTTP響應的原始字符串。
   */
  onSuccess(result: string): void {
    try{
      // 嘗試將響應字符串解析為泛型類型T的對象
      let resultObj: T = JSON.parse(result) asT;

      // 打印原始響應字符串
      console.log("JsonHttpListener  result:" + result);

      // 將解析后的數據通過IDataListener的onSuccess方法回調給調用者
      this.iDataListener.onSuccess(resultObj);
    } catch(error) {
      // 如果解析失敗，打印錯誤信息并調用onFailure方法
      console.error("Error parsing JSON response:", error);
      // 調用失敗處理方法
      this.onFailure(error);
    }
  }

  /**
   * 當HTTP請求失敗時調用此方法。
   * 由于當前實現中沒有處理失敗情況的邏輯，所以此方法會拋出一個錯誤。
   * 實際使用時，應根據需要實現失敗處理邏輯。
   */
  onFailure(error: any): void {
    // 這里可以添加失敗處理邏輯，例如記錄錯誤日志或者通知用戶
    console.error("HTTP request failed:", error.message);
    if(this.iDataListener) {
      // 通知IDataListener接口的實現，請求失敗
      this.iDataListener.onFailure(error);
    }
  }
}

importhttp from'@ohos.net.http';
import{ HttpTask } from'./HttpTask';
import{ IDataListener } from'./IDataListener';
import{ IHttpListener } from'./IHttpListener';
import{ IHttpRequest } from'./IHttpRequest';
import{ JsonHttpListener } from'./JsonHttpListener';
import{ JsonHttpRequest } from'./JsonHttpRequest';

/**
 * JettNetFramework類提供了一個靜態方法用于發送JSON格式的HTTP請求。
 * 該類通過封裝請求任務和監聽器，簡化了網絡請求的發送和處理過程。
 * 泛型T表示請求參數的類型，而泛型M表示響應數據的類型。
 */
export class WNetFramework<T, M> {

  /**
   * 靜態方法，用于發送JSON格式的HTTP請求。
   * @param url - 請求的目標URL。
   * @param header - 請求頭。
   * @param requestParams - 請求的參數，類型為泛型T。
   * @param iDataListener - 實現IDataListener接口的監聽器，用于接收請求結果，類型為泛型M。
   */
  static get<T, M>(url: string, header: Record<string, string>, requestParams: T, iDataListener:
    IDataListener<M>) {
    // 創建JsonHttpRequest對象，用于發送HTTP請求
    let iHttpRequest: IHttpRequest = new JsonHttpRequest();
    // 創建JsonHttpListener對象，用于處理HTTP請求的響應
    let iHttpListener: IHttpListener = new JsonHttpListener<M>(iDataListener);
    // 創建HttpTask對象，封裝請求任務
    let httpTask: HttpTask<T> = new HttpTask(url, header, requestParams, iHttpRequest, iHttpListener);
    // 執行請求任務
    httpTask.run().catch(error => {
      // 調用監聽器的onFailure方法，通知請求失敗
      iDataListener.onFailure(error);
    });
  }

  staticpost<T, M>(url: string, header: Record<string, string>, requestParams: T, iDataListener: IDataListener<M>) {
    // 創建JsonHttpRequest對象，用于發送HTTP請求
    let iHttpRequest: IHttpRequest = newJsonHttpRequest();

    iHttpRequest.setRequestMethod(http.RequestMethod.POST)

    // 創建JsonHttpListener對象，用于處理HTTP請求的響應
    let iHttpListener: IHttpListener = newJsonHttpListener<M>(iDataListener);

    // 創建HttpTask對象，封裝請求任務
    let httpTask: HttpTask<T> = newHttpTask(url, header, requestParams, iHttpRequest, iHttpListener);

    // 執行請求任務
    httpTask.run().catch(error => {
      // 調用監聽器的onFailure方法，通知請求失敗
      iDataListener.onFailure(error);
    });
  }
}

WNetFramework.get<RequestBean, WeatherResponse>(url, headers, null, {
  onSuccess(result: WeatherResponse) {
    console.log("WNetFramework: onSuccess(result:ResponceBean)==>>" + JSON.stringify(result.result));
  }, onFailure(error) {
    console.log("WNetFramework: onFailure(msg)==>>" + JSON.stringify(error.message));
  }
});