// unfinishPage_ApiManager.dart
class UnfinishPageApiManager {
  // 所有页面的所有请求
	static Map<String, dynamic> unfinishPageApiMaps = {}; 
  // 示例
  static Map<String, dynamic> unfinishPageApiMaps =
  {
    "ContentHomePage": [
      {
        apiUrl: api1,
        apiStart: apiStart,
        apiEnd: apiEnd,
      },
      {
        apiUrl: api2,
        apiStart: apiStart,
        apiEnd: apiEnd,
      }
    ],
    "ContentDetailPage": [
      {
        apiUrl: api1,
        apiStart: apiStart,
        apiEnd: apiEnd,
      },
      {
        apiUrl: api2,
        apiStart: apiStart,
        apiEnd: apiEnd,
      }
    ],
  };
  
  // 页面请求开始
  static void startApi({required String api, required String pageKey}) {
    // 加锁🔐
    // 获取指定页面已有的请求列表
    List<Map<String, dynamic>> pageRequestingApiMaps = unfinishPageApiMaps[pageKey] ?? [];
    // 添加新请求
    Map<String, dynamic> newApiInfoMap = {
      apiUrl: api,
      apiStart: apiStart,
    };
    pageRequestingApiMaps.add(newApiInfoMap);
    // 解锁🔐
  }
  
  // 页面请求结束
  static void finishApi({required String api, required String pageKey}) {
    // 加锁🔐
    // 获取指定页面已有的请求列表,及其个数
    List<Map<String, dynamic>> pageRequestingApiMaps = unfinishPageApiMaps[pageKey] ?? [];
    // 找到此请求的开始信息,并补充上此请求的结束信息
    for (Map<String, dynamic> item in pageRequestingApiMaps) {
      item.addAll({"apiEnd": apiEnd});
    }
    int hasFinishCount = pageRequestingApiMaps.length;
    
    // 获取指定页面原本应该有几个请求
    List<Map<String, dynamic>> pageNeedApiMaps = PageApiManager.allNeedPageApiMaps[pageKey] ?? [];
    int needCount = pageNeedApiMaps.length;
   	
    // 判断是否是最后一个请求，是的话上报本次页面的所有所需结束
    if (hasFinishCount >= needCount) {
      _notifyToPage(pageRequestingApiMaps);
    }
    // 解锁🔐
  }
  
  // 通知页面请求完成
  static _notifyToPage(List<Map<String, dynamic>> pageRequestingApiMaps) {
    int minStart;
    int maxEnd;
    for (Map<String, dynamic> item in pageRequestingApiMaps) {
      int itemStart = item["apiStart"];
      int itemEnd = item["apiEnd"];
      if (minStart == null) {
        minStart = itemStart;
      } else {
        minStart = min(minStart, itemStart);
      }
      if (maxEnd == null) {
        maxEnd = itemEnd;
      } else {
        maxEnd = max(maxEnd, itemEnd);
      }
    }
    if (minStart == null || maxEnd == null) {
      debugPrint("发生错误了");
      return;
    }
    int pageApiTotalDuration = maxEnd - minStart;
    Map<String, dynamic> pageApiMap = {
      "page_duration": pageApiTotalDuration,
      "api": {
        "total_duration": {
          "start": 1000,
          "end": 5000,
          "duration": 4000,
        },
        "apis": pageRequestingApiMaps
      }
    }
    eventBus.fire(PageFinishLoadRequest(pageApiMap: pageApiMap));
  }
}

class AllPageTimeManager {
		pageRequestEvent = eventBus.on<PageFinishLoadRequest>().listen((event) {
      Map<String, dynamic> pageApiMap = event.pageApiMap;
    });
    
    
    _uploadToSevice({required Map<String, dynamic> uploadPageInfo}) {
    
    }
}

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