ChickenFarm/UI/CF.APP/chicken_farm/lib/stores/dict_stroe.dart

import 'package:chicken_farm/apis/system/_dict.dart';
import 'package:chicken_farm/core/config/app_config.dart';
import 'package:chicken_farm/core/utils/storage.dart';
import 'package:chicken_farm/modes/system/dict.dart';
import 'package:chicken_farm/core/services/offline_dict_service.dart';

class DictStore {
  static final DictStore _instance = DictStore._internal();
  static const String _localStorgeKey = 'vb_dict_';
  final Map<String, List<DictDataModel>> _cache = {};
  final OfflineDictService _offlineDictService = OfflineDictService();

  factory DictStore() => _instance;

  DictStore._internal();

  /// 根据字典类型获取字典数据列表
  /// 先从缓存中查找，如果缓存中没有则调用接口查询
  Future<List<DictDataModel>?> getDictByType(String dictType) async {
    // 先从内存缓存中查找
    if (_cache.containsKey(dictType)) {
      return _cache[dictType];
    }
    if (AppConfig.isOffline) {
      // 如果是离线模式，则从本地配置中查找
      return await _offlineDictService.getDictByType(dictType);
    } else {
      // 再从本地存储中查找
      final cachedDict = await StorageUtils.getObject<List<dynamic>>(
        '$_localStorgeKey$dictType',
      );
      if (cachedDict != null) {
        try {
          final dictList = cachedDict
              .map(
                (item) => item is Map<String, dynamic>
                    ? DictDataModel.fromJson(item)
                    : null,
              )
              .where((item) => item != null)
              .cast<DictDataModel>()
              .toList();
          _cache[dictType] = dictList;
          return dictList;
        } catch (e) {
          // 解析失败，继续从网络获取
        }
      }

      // 如果本地都没有，则调用接口查询
      final dictData = await DictApi().getDicts(dictType);
      if (dictData != null) {
        // 存入缓存
        _cache[dictType] = dictData;
        await StorageUtils.setObject(
          '$_localStorgeKey$dictType',
          dictData.map((e) => e.toJson()).toList(),
        );

        return dictData;
      }
    }

    return null;
  }

  /// 根据字典类型和值查询标签
  Future<String?> getLabelByTypeAndValue(String dictType, String value) async {
    final dict = await getDictByTypeAndValue(dictType, value);
    return dict?.dictLabel.isNotEmpty == true ? dict?.dictLabel : null;
  }

  /// 根据字典类型和值查询字典项
  Future<DictDataModel?> getDictByTypeAndValue(
    String dictType,
    String value,
  ) async {
    final dictList = await getDictByType(dictType);
    if (dictList != null) {
      final dict = dictList.firstWhere(
        (element) => element.dictValue == value,
        orElse: () => DictDataModel(
          dictCode: 0,
          dictSort: 0,
          dictLabel: '',
          dictValue: '',
          dictType: dictType,
        ),
      );
      // 检查是否找到了匹配的字典项
      if (dict.dictCode != 0 ||
          dict.dictLabel.isNotEmpty ||
          dict.dictValue.isNotEmpty) {
        return dict;
      }
    }
    return null;
  }

  /// 获取所有字典项(离线模式下)
  Future<Map<String, List<DictDataModel>>> getAllOfflineDicts() async {
    if (!AppConfig.isOffline) {
      throw Exception('字典获取操作仅支持离线模式');
    }
    final Map<String, List<DictDataModel>> result = {};
    // 获取所有字典类型
    final dictTypes = await _offlineDictService.getAllDictTypes();

    for (final dictType in dictTypes) {
      final items = await getDictByType(dictType);
      if (items != null && items.isNotEmpty) {
        result[dictType] = items;
      }
    }

    return result;
  }

  /// 清除指定字典类型的缓存
  void clearDictCache(String dictType) {
    _cache.remove(dictType);
    //StorageUtils.remove('$_localStorgeKey$dictType');
  }

  /// 清除所有字典缓存
  void clearAll() {
    _cache.clear();
    //StorageUtils.removeWithPrefix(_localStorgeKey);
  }

  /// 添加新的字典项
  Future<void> addDictItem(String dictType, DictDataModel dictItem) async {
    await _modifyDictList(dictType, (list) {
      list.add(dictItem);
      return list;
    });
  }

  /// 更新字典项
  Future<void> updateDictItem(String dictType, DictDataModel dictItem) async {
    await _modifyDictList(dictType, (list) {
      final index = list.indexWhere(
        (item) => item.dictCode == dictItem.dictCode,
      );
      if (index >= 0) {
        list[index] = dictItem;
      } else {
        list.add(dictItem);
      }
      return list;
    });
  }

  /// 删除字典项
  Future<void> removeDictItem(String dictType, int dictCode) async {
    await _modifyDictList(dictType, (list) {
      list.removeWhere((item) => item.dictCode == dictCode);
      return list;
    });
  }

  /// 修改字典列表的通用方法
  Future<void> _modifyDictList(
    String dictType,
    List<DictDataModel> Function(List<DictDataModel> list) modifier,
  ) async {
    // 只支持离线模式
    if (!AppConfig.isOffline) {
      throw Exception('字典修改操作仅支持离线模式');
    }

    // 获取现有列表或创建一个新列表
    List<DictDataModel>? dictList = _cache[dictType];

    dictList ??= await _offlineDictService.getDictByType(dictType) ?? [];

    // 应用修改
    dictList = modifier(List<DictDataModel>.from(dictList));

    // 按照dictSort排序
    dictList.sort((a, b) => a.dictSort.compareTo(b.dictSort));

    // 更新缓存
    _cache[dictType] = dictList;

    // 保存到本地存储
    await _offlineDictService.saveDict(dictType, dictList);
  }
}