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");
  }
}

return CachedNetworkImage(
     width: width,
     height: height,
     fit: fit,
     imageUrl: imageUrl,
     placeholder: placeholder,
     errorWidget: (context, url, error) {
       if (this.errorWidget != null) {
         return this.errorWidget(context, url, error);
       } else {
         return Container();
       }
     },
   );

TolerantNetworkImage(
        imageUrl: networkUrl,
        width: 100,
        height: 300,
      )

// 定义
ImageProvider imageProvider_network;

// 生成数据
imageProvider_network = CachedNetworkImageProvider(networkUrl);

// 使用数据
return Image(
    image: imageProvider_network,
    width: 100,
    height: 300,
    fit: BoxFit.cover,
  );

return CachedNetworkImage(
     width: width,
     height: height,
     fit: fit,
     imageUrl: imageUrl,
     placeholderFadeInDuration: Duration.zero,
     fadeOutDuration: Duration.zero,
     fadeInDuration: Duration.zero,
     progressIndicatorBuilder: (context, url, progress) {
       return Container(color: Color(0xFFF0F0F0));
     },
   );