fis_lib_measure/lib/process/workspace/measure_data_controller.dart

// ignore_for_file: non_constant_identifier_names

import 'dart:typed_data';

import 'package:fis_common/event/event_type.dart';
import 'package:fis_jsonrpc/rpc.dart';
import 'package:fis_measure/interfaces/process/items/item_metas.dart';
import 'package:fis_measure/interfaces/process/workspace/application.dart';
import 'package:fis_measure/process/workspace/measure_data_helper.dart';
import 'package:fis_measure/process/workspace/rpc_bridge.dart';
import 'package:fis_measure/values/colors.dart';
import 'package:fis_measure/view/measure/measure_config/measure_configuation_page.dart';
import 'package:fis_measure/view/measure/measure_config/widgets/measure_configuration_style.dart';
import 'package:fis_measure/view/measure/measure_config/widgets/measure_configuration_unit.dart';
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:vid/us/vid_us_mode.dart';

class MeasureInfoData {
  final String? patientCode;
  final String? remedicalCode;
  final String? recordCode;
  final String? remedicalAISelectedInfoCode;
  MeasureInfoData({
    this.patientCode,
    this.recordCode,
    this.remedicalCode,
    this.remedicalAISelectedInfoCode,
  });
}

/// 图片信息数据
abstract class IMeasureDataController {
  late FEventHandler<String> aiResultsInfoChanged;
  late FEventHandler<String> measureApplicationVersionChanged;
  late FEventHandler<String> measureLanguageChanged;
  late FEventHandler<DiagnosisConclusionEnum> diagnosisConclusionChanged;
  late FEventHandler<List<RemedicalInfoDTO>> remedicalListResultChanged;
  late FEventHandler<String> itemCurrentImageChanged;
  late FEventHandler<List<ItemMeta>> itemMetaListChanged;
  late FEventHandler<List<String>> getMeasureApplicationChanged;
  late FEventHandler<MeasureInfoData> measureInfoDataChanged;
  late FEventHandler<MeasureSystemSettingDTO> measureSystemSettingChanged;
  late FEventHandler<List<VidUsMode>> applicationModesChanged;
  late FEventHandler<List<ItemMeta>> curItemMetaListChanged;
  late FEventHandler<List<String>> annotationListChanged;
  late FEventHandler<bool> showItemTransStateChanged;

  /// 切换至另一个病人的图像集
  late FEventHandler<Map<String, String>> curMeasureDataChanged;

  /// 该图像下面的应用
  List<ItemMeta> get itemMetaList;
  set itemMetaList(List<ItemMeta> value);

  /// 测量的翻译
  String get measureLanguage;
  set measureLanguage(String value);

  /// 测量应用的版本号
  String get measureApplicationVersion;
  set measureApplicationVersion(String value);

  ///当前选择图像
  String get itemCurrentImage;
  set itemCurrentImage(String value);

  /// 测量图片的ai结果
  String get aiResults;
  set aiResults(String value);

  /// 良恶性 用来判断是否存在ai结果
  DiagnosisConclusionEnum get diagnosisConclusion;
  set diagnosisConclusion(DiagnosisConclusionEnum value);

  /// 测量图片集
  List<RemedicalInfoDTO> get remedicalList;
  set remedicalList(List<RemedicalInfoDTO> value);

  /// 测量方式集
  List<String> get getMeasureApplicationList;
  set getMeasureApplicationList(List<String> value);

  /// 当前载入的测量项列表
  List<ItemMeta> get curItemMetaList;
  set curItemMetaList(List<ItemMeta> value);

  /// 当前所有的注释项
  List<String> get annotationList;
  set annotationList(List<String> value);

  /// 所有的预置的注释项
  PresetCommentItemResultDTO get allPresetAnnotationList;
  set allPresetAnnotationList(PresetCommentItemResultDTO value);

  /// 当前模式下预置的注释项
  List<String> get currPresetAnnotationList;
  set currPresetAnnotationList(List<String> value);

  /// 注释List
  List<CommentItemDTO> get measureCommentItemResult;
  set measureCommentItemResult(List<CommentItemDTO> value);

  /// 测量图片数据
  MeasureInfoData get measureInfoData;
  set measureInfoData(MeasureInfoData value);

  /// 测量样式数据
  MeasureSystemSettingDTO get measureSystemSetting;
  set measureSystemSetting(MeasureSystemSettingDTO value);

  /// 测量当前图片所有模式
  List<VidUsMode> get applicationModes;
  set applicationModes(List<VidUsMode> value);

  /// 测量图片当前模式下所有测量项数据
  List<MeasureModeDTO> get availableModes;
  set availableModes(List<MeasureModeDTO> value);

  List<ItemMetaGroup> get itemMetaListGroup;
  set itemMetaListGroup(List<ItemMetaGroup> itemMetaListGroup);

  String get currentMode;
  set currentMode(String value);

  /// 通用画笔
  Paint get paintPen;
  set paintPen(Paint value);

  /// 卡尺线画笔
  Paint get paintLinePan;
  set paintLinePan(Paint value);

  /// 标记点画笔
  Paint get paintPointPan;
  set paintPointPan(Paint value);

  // int index = 0;

  // int totalCount = 0;

  /// 设置画笔颜色
  ///
  /// [color] 颜色
  void setPenColor(Color color);
}

class MeasureDataController implements IMeasureDataController {
  String _aiResults = '';
  String _itemCurrentImage = '';
  String _measureLanguage = '';
  String _currentMode = '';
  String _measureApplicationVersion = '';
  List<RemedicalInfoDTO> _remedicalList = [];
  List<ItemMeta> _itemMetaList = [];
  List<String> _getMeasureApplicationList = [];
  DiagnosisConclusionEnum _diagnosisConclusion =
      DiagnosisConclusionEnum.NotRequired;
  MeasureInfoData _measureInfoData = MeasureInfoData();
  MeasureSystemSettingDTO _measureSystemSetting = MeasureSystemSettingDTO();
  List<VidUsMode> _applicationModes = [];
  List<MeasureModeDTO> _availableModes = [];
  List<ItemMeta> _curItemMetaList = [];
  List<String> _annotationList = [];
  List<String> _presetAnnotationList = [];
  PresetCommentItemResultDTO _allPresetAnnotationList =
      PresetCommentItemResultDTO();
  List<CommentItemDTO> _measureCommentItemResult = [];
  List<ItemMetaGroup> _itemMetaListGroup = [];

  ///index和totalCount是用于手机端切换图像展示的
  // int index = 0;

  // int totalCount = 0;

  /// 新增的
  List<ItemMetaDTO> itemMetaListConfig = [];

  Paint _paintPen = Paint()
    ..color = MeasureColors.Primary
    ..isAntiAlias = true
    ..strokeWidth = 2
    ..style = PaintingStyle.stroke;

  Paint _paintLinePan = Paint()
    ..color = MeasureColors.Primary
    ..isAntiAlias = true
    ..strokeWidth = 2
    ..style = PaintingStyle.stroke;

  Paint _paintPointPan = Paint()
    ..color = MeasureColors.Primary
    ..isAntiAlias = true
    ..strokeWidth = 2
    ..style = PaintingStyle.stroke;

  @override
  var remedicalListResultChanged = FEventHandler<List<RemedicalInfoDTO>>();

  @override
  var aiResultsInfoChanged = FEventHandler<String>();

  @override
  var measureLanguageChanged = FEventHandler<String>();

  @override
  var measureApplicationVersionChanged = FEventHandler<String>();

  @override
  var diagnosisConclusionChanged = FEventHandler<DiagnosisConclusionEnum>();

  @override
  var itemMetaListChanged = FEventHandler<List<ItemMeta>>();

  @override
  var showItemTransStateChanged = FEventHandler<bool>();

  @override
  var itemCurrentImageChanged = FEventHandler<String>();

  @override
  var getMeasureApplicationChanged = FEventHandler<List<String>>();

  @override
  var measureInfoDataChanged = FEventHandler<MeasureInfoData>();

  @override
  var measureSystemSettingChanged = FEventHandler<MeasureSystemSettingDTO>();

  @override
  var applicationModesChanged = FEventHandler<List<VidUsMode>>();

  @override
  var curItemMetaListChanged = FEventHandler<List<ItemMeta>>();
  @override
  var annotationListChanged = FEventHandler<List<String>>();
  @override
  var curMeasureDataChanged = FEventHandler<Map<String, String>>();
  @override
  List<ItemMeta> get curItemMetaList => _curItemMetaList;

  @override
  set curItemMetaList(List<ItemMeta> value) {
    if (value != _curItemMetaList) {
      _curItemMetaList = value;
      _onCurItemMetaListChanged();
    }
  }

  @override
  List<String> get annotationList => _annotationList;
  @override
  set annotationList(List<String> value) {
    if (value != _annotationList) {
      _annotationList = value;
      _onGetCommentsListChanged();
    }
  }

  @override
  List<String> get currPresetAnnotationList => _presetAnnotationList;
  @override
  set currPresetAnnotationList(List<String> value) {
    if (value != _presetAnnotationList) {
      _presetAnnotationList = value;
    }
  }

  @override
  PresetCommentItemResultDTO get allPresetAnnotationList =>
      _allPresetAnnotationList;
  @override
  set allPresetAnnotationList(PresetCommentItemResultDTO value) {
    if (value != _allPresetAnnotationList) {
      _allPresetAnnotationList = value;
    }
  }

  @override
  List<CommentItemDTO> get measureCommentItemResult =>
      _measureCommentItemResult;
  @override
  set measureCommentItemResult(List<CommentItemDTO> value) {
    if (value != _measureCommentItemResult) {
      _measureCommentItemResult = value;
    }
  }

  @override
  List<MeasureModeDTO> get availableModes => _availableModes;
  @override
  set availableModes(List<MeasureModeDTO> value) {
    if (value != _availableModes) {
      _availableModes = value;
    }
  }

  @override
  MeasureSystemSettingDTO get measureSystemSetting => _measureSystemSetting;
  @override
  set measureSystemSetting(MeasureSystemSettingDTO value) {
    if (value != _measureSystemSetting) {
      _measureSystemSetting = value;
      setGuideline(value.showCursorLine);
      _onMeasureSystemSettingChanged();
    }
  }

  /// 错误单位校验
  void checkErrorUnitConfig() {
    if (!UnitConfigPage.C_DISTANCE_UNIT_LIST
        .contains(_measureSystemSetting.distanceUnit)) {
      _measureSystemSetting.distanceUnit = Unit.cm;
    }
    if (!UnitConfigPage.C_AREA_UNIT_LIST
        .contains(_measureSystemSetting.areaUnit)) {
      _measureSystemSetting.areaUnit = Unit.cm2;
    }
    if (!UnitConfigPage.C_VELOCITY_UNIT_LIST
        .contains(_measureSystemSetting.velocityUnit)) {
      _measureSystemSetting.velocityUnit = Unit.cms;
    }
    if (!UnitConfigPage.C_TIME_UNIT_LIST
        .contains(_measureSystemSetting.timeUnit)) {
      _measureSystemSetting.timeUnit = Unit.msec;
    }
  }

  /// 错误样式设置校验
  void checkErrorStyleConfig() {
    if (!StyleConfigPage.C_MEASURE_CURSOR_SIZE
        .contains(_measureSystemSetting.cursorSize)) {
      _measureSystemSetting.cursorSize =
          StyleConfigPage.C_MEASURE_CURSOR_SIZE[0];
    }
    if (!StyleConfigPage.C_MEASURE_MARK_SIZE
        .contains(_measureSystemSetting.shapeCursorSize)) {
      _measureSystemSetting.shapeCursorSize =
          StyleConfigPage.C_MEASURE_MARK_SIZE[0];
    }
    if (!StyleConfigPage.C_RESULT_TEXT_SIZE
        .contains(_measureSystemSetting.fontSize)) {
      _measureSystemSetting.fontSize = StyleConfigPage.C_RESULT_TEXT_SIZE[0];
    }
    if (!StyleConfigPage.C_ANNOTATION_TEXT_SIZE
        .contains(_measureSystemSetting.annotationFontSize)) {
      _measureSystemSetting.annotationFontSize =
          StyleConfigPage.C_ANNOTATION_TEXT_SIZE[0];
    }
    if (!isContainsValue(StyleConfigPage.C_DISTANCE_THRESHOLD,
        _measureSystemSetting.autoSnapDistance)) {
      _measureSystemSetting.autoSnapDistance =
          StyleConfigPage.C_DISTANCE_THRESHOLD[0].value.toString();
    }
    if (!isContainsValue(StyleConfigPage.C_DISTANCE_THRESHOLD,
        _measureSystemSetting.minCursorDistance)) {
      _measureSystemSetting.minCursorDistance =
          StyleConfigPage.C_DISTANCE_THRESHOLD[0].value.toString();
    }
  }

  void checkCursorColor(Color defaultColor) {
    Color cursorColor = defaultColor;
    final value = _measureSystemSetting.measureColor;
    if (value != null) {
      if (value.startsWith("#")) {
        Color colorFromHex = Color(int.parse(value.substring(1), radix: 16));
        cursorColor = colorFromHex;
      }
    }
    setPenColor(cursorColor);
  }

  bool isContainsValue(List<MeasureSelectModel> list, String? value) {
    if (value == null) return false;
    for (var item in list) {
      if (item.value.toString() == value) {
        return true;
      }
    }
    return false;
  }

  /// 设置是否隐藏卡尺线
  void setGuideline(bool isShow) {
    if (isShow) {
      _paintLinePan.color = MeasureColors.Primary;
    } else {
      _paintLinePan.color = MeasureColors.Hide;
    }
  }

  // 获取自动闭合卡尺线的检测阈值
  double getAutoSnapDistance() {
    if (measureSystemSetting.autoSnapDistance == null) return 0.0;
    try {
      return double.parse(measureSystemSetting.autoSnapDistance!);
    } catch (e) {
      return 0.0;
    }
  }

  double getMinCursorDistance() {
    if (measureSystemSetting.minCursorDistance == null) return 0.0;
    try {
      return double.parse(measureSystemSetting.minCursorDistance!);
    } catch (e) {
      return 0.0;
    }
  }

  @override
  List<VidUsMode> get applicationModes => _applicationModes;
  @override
  set applicationModes(List<VidUsMode> value) {
    if (value != _applicationModes) {
      _applicationModes = value;
      _onApplicationModesChanged();
    }
  }

  @override
  String get currentMode => _currentMode;
  @override
  set currentMode(String value) {
    if (value != _currentMode) {
      _currentMode = value;
    }
  }

  @override
  List<String> get getMeasureApplicationList => _getMeasureApplicationList;
  @override
  set getMeasureApplicationList(List<String> value) {
    if (value != _getMeasureApplicationList) {
      _getMeasureApplicationList = value;
      _onGetMeasureApplicationChanged();
    }
  }

  @override
  List<ItemMeta> get itemMetaList => _itemMetaList;
  @override
  set itemMetaList(List<ItemMeta> value) {
    if (value != _itemMetaList) {
      _itemMetaList = value;
      _onItemMetaListChanged();
    }
  }

  @override
  List<ItemMetaGroup> get itemMetaListGroup => _itemMetaListGroup;
  @override
  set itemMetaListGroup(List<ItemMetaGroup> value) {
    if (value != _itemMetaListGroup) {
      _itemMetaListGroup = value;
      // _onItemMetaListChanged();
    }
  }

  @override
  String get itemCurrentImage => _itemCurrentImage;
  @override
  set itemCurrentImage(String value) {
    if (value != _itemCurrentImage) {
      _itemCurrentImage = value;
      _onItemCurrentImageChanged();
    }
  }

  @override
  String get aiResults => _aiResults;
  @override
  set aiResults(String value) {
    if (value != _aiResults) {
      _aiResults = value;
      _onAIResultsChanged();
    }
  }

  @override
  String get measureLanguage => _measureLanguage;
  @override
  set measureLanguage(String value) {
    if (value != _measureLanguage) {
      _measureLanguage = value;
      _onMeasureLanguageChanged();
    }
  }

  @override
  String get measureApplicationVersion => _measureApplicationVersion;
  @override
  set measureApplicationVersion(String value) {
    if (value != _measureApplicationVersion) {
      _measureApplicationVersion = value;
      _onMeasureApplicationVersion();
    }
  }

  @override
  DiagnosisConclusionEnum get diagnosisConclusion => _diagnosisConclusion;
  @override
  set diagnosisConclusion(DiagnosisConclusionEnum value) {
    if (value != _diagnosisConclusion) {
      _diagnosisConclusion = value;
      _onDiagnosisConclusionChanged();
    }
  }

  @override
  MeasureInfoData get measureInfoData => _measureInfoData;
  @override
  set measureInfoData(MeasureInfoData value) {
    _measureInfoData = value;
    _onMeasureInfoDataChanged();
  }

  @override
  List<RemedicalInfoDTO> get remedicalList => _remedicalList;
  @override
  set remedicalList(List<RemedicalInfoDTO> value) {
    if (value != _remedicalList) {
      _remedicalList = value;
      _onRemedicalListChanged();
    }
  }

  @override
  Paint get paintPen => _paintPen;
  @override
  set paintPen(Paint value) {
    if (value != _paintPen) {
      _paintPen = value;
    }
  }

  @override
  Paint get paintLinePan => _paintLinePan;
  @override
  set paintLinePan(Paint value) {
    if (value != _paintLinePan) {
      _paintLinePan = value;
    }
  }

  @override
  Paint get paintPointPan => _paintPointPan;
  @override
  set paintPointPan(Paint value) {
    if (value != _paintPointPan) {
      _paintPointPan = value;
    }
  }

  MeasureDataController(
    this.saveImage,
  ) {
    _init();
  }
  _init() async {}

  ///参数1：imageBytes 图片字节, 参数2： patientCode 病人code，参数3：recordCode 检查code， 参数4：remedicalCode 检查code，参数5： measuredData 测量值
  Future<bool?> Function(
      Uint8List, String, String, String, String, VidImageSource) saveImage;

  /// 添加注释项
  Future<bool?> addAnnotation(
      IApplication application, String annotationName) async {
    final result = await MeasureDataHelper.saveUserDefinedCommentsAsync(
        application.applicationName,
        application.categoryName,
        [CommentItemDTO(text: annotationName)],
        null,
        null);
    return result;
  }

  /// 删除注释项
  Future<bool?> deleteAnnotation(
      IApplication application, String annotationName) async {
    final result = await MeasureDataHelper.saveUserDefinedCommentsAsync(
        application.applicationName,
        application.categoryName,
        null,
        [CommentItemDTO(text: annotationName)],
        null);
    return result;
  }

  /// 更新注释项
  Future<bool?> updateAnnotation(IApplication application,
      String oldAnnotationName, String newAnnotationName) async {
    final result = await MeasureDataHelper.saveUserDefinedCommentsAsync(
      application.applicationName,
      application.categoryName,
      null,
      null,
      [
        UpdateCommentItemDTO(
            oldText: oldAnnotationName, newText: newAnnotationName)
      ],
    );
    return result;
  }

  /// 选择Vid图像Url
  String chooseImageUrl(TerminalImageDTO dto) {
    // 按Server推荐选择CDN/源站
    final useOrigin =
        dto.recommendedDownloadMode == RecommendedDownloadModeEnum.Origin &&
            dto.originImageUrl != null &&
            dto.originImageUrl!.isNotEmpty;
    final imageUrl = useOrigin ? dto.originImageUrl! : dto.imageUrl!;
    return imageUrl;
  }

  @override
  void setPenColor(Color color) {
    paintPen.color = color;
    paintLinePan.color = color;
    paintPointPan.color = color;
    MeasureColors.ActivePrimary = color;
    if (Get.isRegistered<IApplication>()) {
      Get.find<IApplication>().updateRenderReady.emit(this, null);
    }
  }

  void _onRemedicalListChanged() {
    remedicalListResultChanged.emit(this, remedicalList);
  }

  void _onAIResultsChanged() {
    aiResultsInfoChanged.emit(this, aiResults);
  }

  void _onItemCurrentImageChanged() {
    itemCurrentImageChanged.emit(this, itemCurrentImage);
  }

  void _onItemMetaListChanged() {
    itemMetaListChanged.emit(this, itemMetaList);
  }

  void _onGetMeasureApplicationChanged() {
    getMeasureApplicationChanged.emit(this, getMeasureApplicationList);
  }

  void _onDiagnosisConclusionChanged() {
    diagnosisConclusionChanged.emit(this, diagnosisConclusion);
  }

  void _onMeasureLanguageChanged() {
    measureLanguageChanged.emit(this, measureLanguage);
  }

  void _onMeasureApplicationVersion() {
    measureApplicationVersionChanged.emit(this, measureApplicationVersion);
  }

  void _onMeasureInfoDataChanged() {
    measureInfoDataChanged.emit(this, measureInfoData);
  }

  void _onMeasureSystemSettingChanged() {
    measureSystemSettingChanged.emit(this, measureSystemSetting);
  }

  void _onApplicationModesChanged() {
    applicationModesChanged.emit(this, applicationModes);
  }

  void _onCurItemMetaListChanged() {
    curItemMetaListChanged.emit(this, curItemMetaList);
  }

  void _onGetCommentsListChanged() {
    annotationListChanged.emit(this, annotationList);
  }
}