fis_lib_measure/lib/view/measure/measure_view_controller.dart

import 'package:fis_common/logger/logger.dart';
import 'package:fis_jsonrpc/rpc.dart';
import 'package:fis_measure/interfaces/process/items/item_metas.dart';
import 'package:fis_measure/interfaces/process/items/terms.dart';
import 'package:fis_measure/interfaces/process/items/types.dart';
import 'package:fis_measure/interfaces/process/workspace/application.dart';
import 'package:fis_measure/interfaces/process/workspace/measure_3d_view_controller.dart';
import 'package:fis_measure/process/items/item_meta_convert.dart';
import 'package:fis_measure/process/workspace/measure_3d_view_controller.dart';
import 'package:fis_measure/process/workspace/measure_data_controller.dart';
import 'package:fis_measure/process/workspace/measure_handler.dart';
import 'package:fis_measure/view/measure/measure_config/measure_configuation_page.dart';
import 'package:get/get.dart';
import 'package:vid/us/vid_us_unit.dart';

class MeasureMetaController extends GetxController {
  /// 数据
  late final measureData = Get.find<MeasureDataController>();
  late final measureHandler = Get.find<MeasureHandler>();
  late final measure3DViewController = Get.find<Measure3DViewController>();
  get isCarotid2D =>
      measure3DViewController.curMeasureMode == MeasureMode.carotid2DMode;

  /// 跟超声机端保持一致，配置 项目写死
  List<ItemMetaGroup> getMeasureConfigurationGroupName() {
    return [
      ItemMetaGroup('Common', [], true),
      ItemMetaGroup('ABD', [], false),
      ItemMetaGroup('CARD', [], false),
      ItemMetaGroup('GYN', [], false),
      ItemMetaGroup('OB', [], false),
      ItemMetaGroup('VAS', [], false),
      ItemMetaGroup('VET', [], false),
      // ItemMetaGroup('URM', [], false),
    ];
  }

  /// 获取组合测量项
  void updateItemList() {
    if (isCarotid2D) return; //颈动脉2D采用写死的测量项，无需更新

    /// 格式化数据
    List<ItemMeta> itemMetaList = [];
    for (var element in measureData.itemMetaList) {
      if (measureData.getMeasureApplicationList.contains(element.description)) {
        itemMetaList.add(element);
      }
    }
    // TODO: Remove mock
    // _mockAddLvStudy(itemMetaList);
    measureData.curItemMetaList = itemMetaList;
  }

  void _mockAddLvStudy(List<ItemMeta> itemMetaList) {
    itemMetaList.insert(
      1,
      ItemMeta(
        MeasureTerms.LvStudy,
        measureType: MeasureTypes.LvStudyByLineGroupTissue,
        description: MeasureTypes.Distance,
        briefAnnotation: "LvStudy",
        outputs: [
          ItemOutputMeta(MeasureTerms.LvStudy, "LvStudy", VidUsUnit.None),
          ItemOutputMeta(MeasureTerms.LVEDV, "LVEDV", VidUsUnit.ml),
          ItemOutputMeta(MeasureTerms.LVESV, "LVESV", VidUsUnit.ml),
          ItemOutputMeta(MeasureTerms.SV, "SV", VidUsUnit.ml),
          ItemOutputMeta(MeasureTerms.LVdMass, "LVd Mass", VidUsUnit.g),
          ItemOutputMeta(MeasureTerms.EF, "EF", VidUsUnit.percent),
          ItemOutputMeta(MeasureTerms.FS, "%FS", VidUsUnit.percent),
          ItemOutputMeta(MeasureTerms.PercentIVS, "%IVS", VidUsUnit.percent),
          ItemOutputMeta(MeasureTerms.PercentLVPW, "%LVPW", VidUsUnit.percent),
        ],
        childItems: [
          ItemMeta(
            MeasureTerms.IVSd,
            description: "IVSd",
            measureType: MeasureTypes.Distance,
            outputs: [
              ItemOutputMeta(MeasureTerms.IVSd, "IVSd", VidUsUnit.mm),
            ],
          ),
          ItemMeta(
            MeasureTerms.LVIDd,
            description: "LVIDd",
            measureType: MeasureTypes.Distance,
            outputs: [
              ItemOutputMeta(MeasureTerms.LVIDd, "LVIDd", VidUsUnit.mm),
            ],
          ),
          ItemMeta(
            MeasureTerms.LVPWd,
            description: "LVPWd",
            measureType: MeasureTypes.Distance,
            outputs: [
              ItemOutputMeta(MeasureTerms.LVPWd, "LVPWd", VidUsUnit.mm),
            ],
          ),
          ItemMeta(
            MeasureTerms.IVSs,
            description: "IVSs",
            measureType: MeasureTypes.Distance,
            outputs: [
              ItemOutputMeta(MeasureTerms.IVSs, "IVSs", VidUsUnit.mm),
            ],
          ),
          ItemMeta(
            MeasureTerms.LVIDs,
            description: "LVIDs",
            measureType: MeasureTypes.Distance,
            outputs: [
              ItemOutputMeta(MeasureTerms.LVIDs, "LVIDs", VidUsUnit.mm),
            ],
          ),
          ItemMeta(
            MeasureTerms.LVPWs,
            description: "LVPWs",
            measureType: MeasureTypes.Distance,
            outputs: [
              ItemOutputMeta(MeasureTerms.LVPWs, "LVPWs", VidUsUnit.mm),
            ],
          ),
        ],
      ),
    );
  }

  void setAvailableModes(String name) {
    List<MeasureModeDTO> models = measureData.availableModes;
    measureData.currentMode = name;
    if (models.isNotEmpty) {
      ///群组列表
      var groups = models
          .firstWhereOrNull(
              (element) => element.modeName == measureData.currentMode)
          ?.availableGroups;

      if (groups != null && groups.isNotEmpty) {
        ///项目列表
        var folders = groups[0].availableFolders;
        if (folders != null && folders.isNotEmpty) {
          measureData.getMeasureApplicationList =
              folders[0].workingItemNames ?? [];
          if (folders[0].availableItems != null) {
            measureData.itemMetaList = folders[0]
                .availableItems!
                // 排除不支持的测量项
                .where((element) =>
                    !MeasureUnsupportedTerms.items.contains(element.name))
                .map((element) {
                  try {
                    if (element.name == 'LV Study') {
                      print(element);
                    }
                    return ItemMetaConverter(element).output();
                  } catch (e) {
                    logger.e(
                      "Item meta -[${element.name}] convert error; JSON-Text: ${element.toJson()}",
                      e,
                    );
                    return null;
                  }
                })
                .where((element) => element != null)
                .map((e) => e!)
                .toList();
            updateItemList();
          }
          if (measureData.getMeasureApplicationList.isNotEmpty) {
            measureData.curItemMetaListChanged.emit(this, []);
          }
        }
      }
    }
  }

  List<ItemMetaDTO> setMeasureConfigItemMetaList() {
    List<ItemMetaDTO> _measureConfigItemMetaList = [];
    var groups = measureData.availableModes
        .firstWhereOrNull(
            (element) => element.modeName == measureData.currentMode)
        ?.availableGroups;
    (groups![0].availableFolders![0].availableItems)?.toList().forEach(
      (e) {
        if (!MeasureUnsupportedTerms.items.contains(e.name)) {
          _measureConfigItemMetaList.add(e);
        }
      },
    );

    return _measureConfigItemMetaList;
  }

  /// 测量项配置组
  void measureConfig() {
    List<ItemMetaGroup> _itemMetaConfigurationList = [];
    Map<String, List<ItemMetaDTO>> _group = {};
    getMeasureConfigurationGroupName().forEach(
      ((element) {
        List<ItemMetaDTO> itemMetaListGroupItem = [];
        var groups = measureData.availableModes
            .firstWhereOrNull(
                (element) => element.modeName == measureData.currentMode)
            ?.availableGroups;
        (groups![0].availableFolders![0].availableItems)?.toList().forEach(
          (e) {
            if (e.categories!.toList().contains(element.itemMetaGroupTitle)) {
              if (!MeasureUnsupportedTerms.items.contains(e.name)) {
                itemMetaListGroupItem.add(e);
              }
            }
            _group[element.itemMetaGroupTitle] = itemMetaListGroupItem;
          },
        );
      }),
    );
    _group.forEach(
      (key, value) {
        if (key == 'Common') {
          _itemMetaConfigurationList.add(
            ItemMetaGroup(key, value, true),
          );
        } else {
          _itemMetaConfigurationList.add(
            ItemMetaGroup(key, value, false),
          );
        }
      },
    );
    measureData.itemMetaListGroup = _itemMetaConfigurationList;
  }

  void changeItem(ItemMeta itemMeta) {
    final application = Get.find<IApplication>();
    application.switchItem(itemMeta);
  }
}