// post 请求
AppNetworkRequestUtil.post
  
// get 请求
AppNetworkRequestUtil.get

// post 请求
AppNetworkCacheUtil.post
  
// get 请求
AppNetworkCacheUtil.get

AppNetworkListCacheUtil.post

class UserRequest {
  // 登录-普通
  static login_normal({
    String mobile,
    String smsCode,
    void Function(UserModel userModel) completeBlock,
  }) {
    return AppNetworkRequestUtil.post(
      UrlPath.doLogin,
      params: {
        "mobile": mobile,
        "smsCode": smsCode,
        "grantType": "sms_code",
      },
    ).then((ResponseModel responseModel) {
      if (responseModel.isSuccess != true) {
        completeBlock(null);
        return;
      }

      User_manager_bean baseUserModel;
      if (responseModel.result != null) {
        baseUserModel = UserModel.fromJson(responseModel.result);
      } else {
        baseUserModel = null;
      }
      completeBlock(baseUserModel);
    });
  }
}

Future<ResponseModel> requestWithRetry(
    String api, {
    RequestMethod requestMethod = RequestMethod.post,
    Map<String, dynamic>? customParams,
    int retryCount = 0, // 轮询次数,最后一次不管成功与否都要返回
    Duration retryDuration = const Duration(milliseconds: 1000), // 轮询间隔
    bool Function(ResponseModel responseModel)?
        retryStopConditionConfigBlock, // 是否请求停止的判断条件(为空时候,默认请求成功即停止)
    Options? options,
    bool withLoading = false,
    bool?
        toastIfMayNeed, // 应该弹出toast的地方是否要弹出toast(如网络code为500的时候),必须可为空是,不为空的时候无法实现修改

    ResponseModel? beforeResponseModel, // 上一次请求时候得到的值(重试\缓存)
  }) async {
    return requestUrl(
      api,
      requestMethod: requestMethod,
      customParams: customParams,
      options: options,
      withLoading: withLoading,
      toastIfMayNeed: toastIfMayNeed,
    ).then((ResponseModel responseModel) {
      if (beforeResponseModel != null) {
        if (responseModel.isEqualToResponse(beforeResponseModel)) {
          responseModel.isSameToBefore = true;
        }
      }

      bool allowRetryIfFailure = retryCount > 1;
      if (allowRetryIfFailure != true) {
        // 重试次数用完的话，最后一次不管成功与否都要返回
        return responseModel;
      }

      // 如果实际的请求成功，则直接返回
      bool noneedRetry = responseModel.isSuccess;
      if (retryStopConditionConfigBlock != null) {
        noneedRetry = retryStopConditionConfigBlock(responseModel);
      }
      if (noneedRetry) {
        return responseModel;
      } else {
        // 如果实际的请求失败，则尝试再进行请求
        retryCount--;

        return Future.delayed(retryDuration).then((value) {
          return requestWithRetry(
            api,
            requestMethod: requestMethod,
            customParams: customParams,
            retryCount: retryCount,
            retryDuration: retryDuration,
            retryStopConditionConfigBlock: retryStopConditionConfigBlock,
            options: options,
            withLoading: withLoading,
            toastIfMayNeed: toastIfMayNeed,
            beforeResponseModel: responseModel,
          );
        });
      }
    });
  }

/// 可进行缓存的请求(需要多次返回结果)
  // ignore: non_constant_identifier_names
  void cache_requestWithCallback(
    String api, {
    RequestMethod requestMethod = RequestMethod.post,
    Map<String, dynamic>? customParams,
    bool? ifNoAuthorizationForceGiveUpRequest, // 没有 Authorization 的时候是否强制放弃请求
    int retryCount = 0,
    NetworkCacheLevel cacheLevel = NetworkCacheLevel.none,
    required void Function(ResponseModel responseModel) completeCallBack,
    ResponseModel? cacheResponseModel,
  }) async {
    /*
    bool shouldGiveUp = await super.shouldGiveUpRequest(api);
    // 此时可能网络初始化还没完成(PS:初始化操作在base_requestUrl中 await _initCompleter.future;)
    if (shouldGiveUp) {
      LogApiUtil.logCancelApi(api);
      return;
    }
    */

    if (ifNoAuthorizationForceGiveUpRequest == true) {
      if (await existAuthorization() == false) {
        return;
      }
    }

    ResponseModel responseModel = await requestWithRetry(
      api,
      requestMethod: requestMethod,
      customParams: customParams,
      retryCount: retryCount,
      options: CacheHelper.buildOptions(cacheLevel),
      beforeResponseModel: cacheResponseModel,
    );

    // 不是真正的网络请求返回的Response\Error结果(eg:比如是取缓存的结果时候)
    // bool noRealRequest = cacheLevel == NetworkCacheLevel.one;
    if (responseModel.isCache != true) {
      // 1、当请求结果是后台实际请求返回的时候:
      if (responseModel.isSuccess) {
        // ①.如果实际的请求成功，则直接返回
        completeCallBack(responseModel);
      } else {
        // ②.如果实际的请求失败，由于 statusCode 在200到300之间的请求结果都会被保存起来，但我们此系统里他们可能是错误的。
        // 如500，就不要保存起来了，防止请求的时候发现有缓存数据，使得页面使用到了保存的数据
        if (cacheLevel != NetworkCacheLevel.none) {
          Uri uri = getUri(api);
          String requestMethodString = requestMethod.toString().split('.').last;
          bool deleteSuccess = await deleteByPrimaryKeyAndSubKeyWithUri(uri,
              requestMethod: requestMethodString, data: customParams);
          if (deleteSuccess == false) {
            _log("Warning:此份网络数据结果本不该存储，但存了，现在必须删却又没删除成功的接口");
          }
        }
        completeCallBack(responseModel);
      }
    } else {
      // 2、请求结果是之前缓存的数据返回的(即结果是真正的网络请求返回的Response\Error结果)的时候，
      // ①先把缓存返回回去，
      // ②再继续发起实际的请求，且新请求为后台实际请求并且其要会保存请求成功的数据
      completeCallBack(responseModel);

      late NetworkCacheLevel newCacheLevel;
      if (cacheLevel == NetworkCacheLevel.one) {
        newCacheLevel = NetworkCacheLevel.forceRefreshAndCacheOne;
      } else {
        _log(
            'Error：$api判断出错啦，此结果不是缓存数据，却走到了isCache==true'); // TODO:无网络的情况下会发生此现象
        newCacheLevel = NetworkCacheLevel
            .none; //TODO:临时为了走下去，应该自始至终都不会走到这里，这里之后要 throw Exception
      }

      cache_requestWithCallback(
        api,
        requestMethod: requestMethod,
        customParams: customParams,
        cacheLevel: newCacheLevel,
        completeCallBack: completeCallBack,
        cacheResponseModel: responseModel, // 缓存数据
      );
    }
  }

void requestWithCallback(
    String api, {
    RequestMethod requestMethod = RequestMethod.post,
    Map<String, dynamic>? customParams,
    bool? ifNoAuthorizationForceGiveUpRequest, // 没有 Authorization 的时候是否强制放弃请求
    int retryCount = 0,
    AppNetworkCacheLevel cacheLevel = AppNetworkCacheLevel.none,
    withLoading = false,
    bool? showToastForNoNetwork,
    required void Function(ResponseModel responseModel) completeCallBack,
  }) async {
    AppMockManager.tryDealApi(
      api,
      isGet: requestMethod == RequestMethod.get ? true : false,
    );

    // ignore: todo
    /* ///TODO:判断不准确，临时注释起来
    if (cacheLevel != NetworkCacheLevel.one) {
      // 不是取缓存的请求的时候，才需要取网络
      if (NetworkStatusManager().connectionStatus == NetworkType.none) {
        ResponseModel newResponseModel = checkResponseModelFunction(
          ResponseModel.nonetworkResponseModel(),
          showToastForNoNetwork: showToastForNoNetwork,
        );

        if (completeCallBack != null) {
          completeCallBack(newResponseModel);
        }
        return;
      }
    }
    */

    if (withLoading == true) {
      LoadingUtil.show();
    }

    cache_requestWithCallback(
      api,
      requestMethod: requestMethod,
      customParams: customParams,
      ifNoAuthorizationForceGiveUpRequest: ifNoAuthorizationForceGiveUpRequest,
      retryCount: retryCount,
      cacheLevel: cacheLevel == AppNetworkCacheLevel.one
          ? NetworkCacheLevel.one
          : NetworkCacheLevel.none,
      completeCallBack: (ResponseModel responseModel) {
        if (withLoading == true && responseModel.isCache != true) {
          LoadingUtil.dismiss();
        }

        ResponseModel newResponseModel = checkResponseModelFunction(
          responseModel,
          toastIfMayNeed: showToastForNoNetwork,
        );

        completeCallBack(newResponseModel);
      },
    );
  }

class AppNetworkCacheUtil {
  String api;
  Map<String, dynamic>? params;
  bool? ifNoAuthorizationForceGiveUpRequest; // 没有 Authorization 的时候是否强制放弃请求
  int retryCount;
  bool withLoading;
  AppNetworkCacheLevel cacheLevel;
  bool? showToastForNoNetwork;

  RequestMethod requestMethod = RequestMethod.post;

  AppNetworkCacheUtil.get(
    this.api, {
    this.params,
    this.ifNoAuthorizationForceGiveUpRequest,
    this.retryCount = 0,
    this.withLoading = false,
    this.cacheLevel = AppNetworkCacheLevel.one,
    this.showToastForNoNetwork,
  }) {
    requestMethod = RequestMethod.get;
  }

  AppNetworkCacheUtil.post(
    this.api, {
    this.params,
    this.ifNoAuthorizationForceGiveUpRequest,
    this.retryCount = 0,
    this.withLoading = false,
    this.cacheLevel = AppNetworkCacheLevel.one,
    this.showToastForNoNetwork,
  }) {
    requestMethod = RequestMethod.post;
  }

  void then(
    void Function(ResponseModel responseModel) completeCallBack,
  ) async {
    AppNetworkManager().requestWithCallback(
      api,
      requestMethod: requestMethod,
      customParams: params,
      ifNoAuthorizationForceGiveUpRequest: ifNoAuthorizationForceGiveUpRequest,
      retryCount: retryCount,
      cacheLevel: cacheLevel,
      withLoading: withLoading,
      showToastForNoNetwork: showToastForNoNetwork,
      completeCallBack: completeCallBack,
    );
  }
}

extension Cache on AppNetworkManager {
  /// 列表的请求(未设置会自动补上 pageNum pageSize 参数)
  void postListWithCallback(
    String api, {
    required Map<String, dynamic> customParams,
    int retryCount = 0,
    AppListCacheLevel listCacheLevel = AppListCacheLevel.one,
    withLoading = false,
    bool? showToastForNoNetwork,
    required void Function(ResponseModel responseModel) completeCallBack,
  }) async {
    if (customParams['pageSize'] == null) {
      customParams.addAll({"pageSize": 20});
    }

    AppNetworkCacheLevel cacheLevel = AppNetworkCacheLevel.none;
    if (customParams['pageNum'] != null) {
      int pageNum = customParams['pageNum'];
      if (listCacheLevel == AppListCacheLevel.one && pageNum == 1) {
        cacheLevel = AppNetworkCacheLevel.one;
      }
    }

    requestWithCallback(
      api,
      requestMethod: RequestMethod.post,
      customParams: customParams,
      retryCount: retryCount,
      cacheLevel: cacheLevel,
      withLoading: withLoading,
      showToastForNoNetwork: showToastForNoNetwork,
      completeCallBack: completeCallBack,
    );
  }
  
}

bool? toastIfMayNeed; //可空字段

import 'package:flutter_data_helper/flutter_data_helper.dart';

// --------------------------  商品售卖状态  --------------------------
// 商品售卖状态(上架:up; 下架:down)
enum GoodsSaleState {
  up, // 上架中
  down, // 已下架
}

///string转枚举类型
GoodsSaleState goodsSaleStateFromString(String value) {
  Iterable<GoodsSaleState> values = [
    GoodsSaleState.up, // 上架中
    GoodsSaleState.down, // 已下架
  ];
  return EnumStringUtil.enumFromString(values, value);
}

///枚举类型转string
String goodsSaleStateStringFromEnum(o) {
  return EnumStringUtil.enumToString(o);
}

// --------------------------  商品物品类型  --------------------------
// 商品物品类型(实体商品:physical; 虚拟物品:virtual)
enum GoodsPhysicalType {
  physical, // 实体商品
  virtual, // 虚拟物品
}

// 商品价格
import 'base_goods_enum.dart';

abstract class GoodsPriceModel {
  int? marketPrice; // 市场价格
  int? salePrice; // 销售价格
}

// 商品品牌
abstract class GoodsBrandModel {
  String? brandId; // 品牌id
  String? brandName; // 品牌名称
}

// 商品门店
abstract class GoodsShopModel {
  String? shopId; // 门店id
  String? shopName; // 门店名称
}

// 商品基类
class BaseGoodsBean implements GoodsPriceModel, GoodsBrandModel, GoodsShopModel {
  // 商品必备属性
  final String id; // 商品id
  final String name; // 商品名称
  final String imageOrVideoUrl; // 商品主图图片/视频
  final GoodsSaleState goodsSaleState; // 商品售卖状态(上架up; 下架down)
  final GoodsPhysicalType physicalType; // 商品物品类型(实体商品:physical; 虚拟物品:virtual)

  // 商品价格
  @override
  int? marketPrice;
  @override
  int? salePrice;

  // 商品品牌
  @override
  String? brandId;
  @override
  String? brandName;

  // 商品门店
  @override
  String? shopId;
  @override
  String? shopName;

  BaseGoodsBean({
    required this.id,
    required this.name,
    required this.imageOrVideoUrl,
    required this.goodsSaleState,
    required this.physicalType,
    this.marketPrice,
    this.salePrice,
    this.brandId,
    this.brandName,
    this.shopId,
    this.shopName,
  });
}

class UserBaseBean {
  final String userId;
  final String? avatar;
  final String? nickname;
  final int? consumerLevel; // 用户等级

  UserBaseBean({
    required this.userId,
    this.avatar,
    this.nickname,
    this.consumerLevel,
  });
}

// 商品价格
abstract class GoodsPriceModel {
  int? marketPrice; // 市场价格
  int? salePrice; // 销售价格
}

// 商品品牌
abstract class GoodsBrandModel {
  String? brandName; // 品牌名称
  String? brandId; // 品牌id
}

// 商品基类
class BaseGoodsBean implements GoodsPriceModel, GoodsBrandModel {
  // 商品价格
  @override
  int? marketPrice;
  @override
  int? salePrice;

  // 商品品牌
  @override
  String? brandName;
  @override
  String? brandId;
}

if (cacheFlie.existsSync()) {  /// existsSync是一个同步方法，用于检查具有该路径的文件系统实体是否存在。

final Directory _cacheImagesDirectory = Directory(
    join((await getTemporaryDirectory()).path, cacheImageFolderName));

// exist, try to find cache image file
if (_cacheImagesDirectory.existsSync()) { /// existsSync是一个同步方法，用于检查具有该路径的文件系统实体是否存在。
  final File cacheFlie = File(join(_cacheImagesDirectory.path, md5Key));
  if (cacheFlie.existsSync()) {  /// existsSync是一个同步方法，用于检查具有该路径的文件系统实体是否存在。
    
  }
}

/// get md5 from key
static String keyToMd5(String key) => md5.convert(utf8.encode(key)).toString();

/// 获取网络图片最后的本地存储文件夹路径
static Future<String> getLastDirPath(String imageUrl, {bool? useSubDir}) async {
  Directory cacheDir = await getTemporaryDirectory();
  String imageCacheHomeDirPath = join(cacheDir.path, cacheImageFolderName);
  if (useSubDir != true) { // 不使用子目录，直接一个文件夹存放
    return imageCacheHomeDirPath;
  }

  String subDirHome = keyToMd5(imageUrl);
  String imageCacheSubDirName = subDirHome.substring(0, 1);
  String lastDirPath = "$imageCacheHomeDirPath/$imageCacheSubDirName";
  return lastDirPath;
}

/// 计算图片文件的查找耗时(查找失败返回-1)
static Future<int> calculateFindDuration(String imageUrl, {bool? useSubDir}) async {
  String md5Key = keyToMd5(imageUrl);
  final String lastDirPath = await getLastDirPath(imageUrl, useSubDir: useSubDir);
  final Directory cacheImagesDirectory = Directory(lastDirPath);

  int foundStartTime = DateTime.now().millisecondsSinceEpoch;
  // exist, try to find cache image file
  if (cacheImagesDirectory.existsSync()) { /// existsSync同步方法，检查该路径的文件夹是否存在
    final File cacheFlie = File(join(cacheImagesDirectory.path, md5Key));
    if (cacheFlie.existsSync()) { /// existsSync同步方法，检查该路径的文件是否存在
      int foundEndTime = DateTime.now().millisecondsSinceEpoch;
      int foundDuration = foundEndTime - foundStartTime;
      return foundDuration;
    }
  }

  return -1;
}

import 'dart:convert';
import 'package:crypto/crypto.dart';

class ConsistentHashing {
  List<String> nodes;
  Map<int, String> ring;

  // 构造hash环
  ConsistentHashing(List<String> nodes) {
    this.nodes = nodes;
    this.ring = {};

    for (String node in nodes) {
      addNode(node);
    }
  }

  // ring[_hash(node + n.toString())] = node;
  void addNode(String node) {			// a、b...
    for (int n = 0; n < 3; n++) { // 每个节点有3个虚拟节点（a0、a1、a2、b0、b1、b2...）
      String virtualNode = node + n.toString();
      int hashValue = _hash(virtualNode);
      ring[hashValue] = node;  // {hash_a0: "a", hash_a1: "a", hash_a2: "a"}
    }
  }
  
	// ring.remove(_hash(node + n.toString()));
  void removeNode(String node) {	// a、b...
    for (int n = 0; n < 3; n++) { // 每个节点有3个虚拟节点（a0、a1、a2、b0、b1、b2...）
      String virtualNode = node + n.toString();
      int hashValue = _hash(virtualNode);
      ring.remove(hashValue);
    }
  }

  // 从小到大排序所有虚拟节点的hash值，并进行遍历，找到最接近(第一个>=hashValue的节点）的虚拟节点。判断值应该存储的节点
  String getNode(String key) {
    if (ring.isEmpty) {
      return null;
    }

    int hashValue = _hash(key);
    List<int> sortedKeys = ring.keys.toList()..sort(); // [hash_a0, hash_b0, hash_a1, hash_b1, ...]
    for (int ringKey in sortedKeys) {
      if (hashValue <= ringKey) { // hash_xxx <=  hash_a1 遍历找到第一个大于等于 hash_xxx 的节点
        return ring[ringKey]; // ring[hash_a1] = "a"  => 返回 "a"
      }
    }

    return ring[sortedKeys[0]];
  }

  int _hash(String key) {
    Digest hash = md5.convert(utf8.encode(key));
    int hashValue = int.parse(hash.toString(), radix: 16);
    return hashValue;
  }
}

void main() {
  // 创建36个文件节点，每个节点对应一个字母或数字
  List<String> nodes = List.generate(26, (index) => String.fromCharCode(97 + index))
      ..addAll(List.generate(10, (index) => index.toString()));

  // 初始化一致性哈希环
  ConsistentHashing ring = ConsistentHashing(nodes);

  // 假设有一批图片文件需要存储
  List<String> imageFiles = ['image1.jpg', 'image2.jpg', 'image3.jpg'];

  for (String imageFile in imageFiles) {
    // 根据文件名获取对应的节点
    String node = ring.getNode(imageFile);

    // 将文件存储到对应的节点中
    // 这里可以根据需要自行实现文件存储逻辑
    print('Storing $imageFile to node $node');
  }
}

/// [图片处理方式:快速缩略模板](https://cloud.tencent.com/document/product/460/6929)
/// [图片处理方式:数据万象-缩放thumbnail](https://cloud.tencent.com/document/product/460/36540)
/// [图片处理方式:数据万象-旋转rotate](https://cloud.tencent.com/document/product/460/36542)
class TSTooManyImageDataVientiane {
  static String newImageUrl(String imageUrl, {required int width}) {
    String thumbnail = '?imageMogr2/thumbnail/';
    thumbnail += '${width}x/';
    thumbnail += 'format/webp/auto-orient/quality/100';

    String newImageUrl = "$imageUrl$thumbnail";
    // debugPrint('newImageUrl = $newImageUrl');
    return newImageUrl;
  }
}

import 'dart:io';

import 'package:extended_image/extended_image.dart';
import 'ts_toomany_image_data_vientiane.dart';

class TSTooManyImageDownloadUtil {
  static String vientianeImageUrl = "https://images.xihuanwu.com/mcms/uploads/1647604960983901.jpg";

  static void simulate_download_too_many(int imageWidthStart, int imageWidthEnd) {
    int imageCount = imageWidthEnd - imageWidthStart;
    for (var i = 0; i < imageCount; i++) {
      int iImageWidth = imageWidthStart + i;
      String iImageUrl = TSTooManyImageDataVientiane.newImageUrl(vientianeImageUrl, width: iImageWidth);
      getNetworkImageData(iImageUrl);
      sleep(const Duration(milliseconds: 10)); // 延迟10ms，避免下载太多计算问题
    }
  }
}

import 'dart:convert';
import 'dart:io';
import 'package:crypto/crypto.dart';
import 'package:flutter/foundation.dart';
import 'package:path/path.dart';
import 'package:path_provider/path_provider.dart';
import 'package:extended_image_library/extended_image_library.dart';

import 'ts_toomany_image_data_vientiane.dart';
import 'ts_toomany_image_download_util.dart';

class TSTooManyImageOptimizeCheckUtil {
  /// 计算图片的查找时长
  static checkImageFindDuration() async {
    String foundImageUrl = TSTooManyImageDataVientiane.newImageUrl(TSTooManyImageDownloadUtil.vientianeImageUrl,
        width: 6600);
    getNetworkImageData(foundImageUrl);
    int foundDuration = await TSTooManyImageOptimizeCheckUtil.calculateFindDuration(foundImageUrl);
    debugPrint("$foundImageUrl 的查找时间为:$foundDuration");
  }
}