fis_lib_measure/lib/process/workspace/measure_data_helper.dart

// ignore_for_file: constant_identifier_names

import 'dart:convert';
import 'package:fis_common/logger/logger.dart';
import 'package:fis_jsonrpc/rpc.dart';
import 'package:fis_measure/process/workspace/measure_handler.dart';
import 'package:fis_measure/process/workspace/rpc_bridge.dart';
import 'package:fis_i18n/i18n.dart';
import 'package:flutter/foundation.dart';

class MeasureDataHelper {
  // static VidImageSource source = VidImageSource.Remedical;
  static get source => RPCBridge.ins.source;
  // 获取图像列表
  static Future<List<RemedicalItemList>> getRemedicalList(
      String patientCode, String recordCode) async {
    try {
      // 初始化为空列表
      List<RemedicalItemList> remedicalItems = [];
      // 当数据来源是 Consultation 时
      if (source == VidImageSource.Consultation) {
        // 获取咨询图片
        var images = await getConsultationImages(recordCode);

        // 遍历图片列表，将非空的 imageInfos 添加到 remedicalItems 中
        images.forEach((imageInfo) {
          var imageInfos = imageInfo.ultrasoundImageList ?? [];
          if (imageInfos.isNotEmpty) {
            remedicalItems.add(RemedicalItemList(
              remedicalList: imageInfos,
            ));
          }
        });
      }
      // 当数据来源是 Laboratory 时
      else if (source == VidImageSource.Laboratory) {
        // 获取患者的文件列表
        var getRecordsPage =
            await RPCBridge.ins.rpc.lab.getFileListByFolderAsync(
          GetFileListByFolderRequest(
            token: RPCBridge.ins.userToken,
            pageIndex: 1,
            pageSize: 100,
            folderCode: patientCode,
          ),
        );
        remedicalItems.add(RemedicalItemList(
          remedicalList: getRecordsPage.pageData,
        ));
      }
      // 当数据来源为ai结果编辑的
      else if (source == VidImageSource.AiResultModifier) {
        var result =
            await RPCBridge.ins.rpc.remedical.getPatientAISelectedInfosAsync(
          GetPatientAISelectedInfosRequest(
            token: RPCBridge.ins.userToken,
            recordCode: recordCode,
          ),
        );
        List<RemedicalInfoDTO> remedicalInfoList = [];
        result.forEach((element) {
          remedicalInfoList.add(RemedicalInfoDTO(
            recordCode: element.recordCode,
            remedicalCode: element.remedicalAISelectedInfoCode,
            terminalImages: TerminalImageDTO(
              previewUrl: element.previewFileToken,
              imageUrl: element.cdnFileToken,
              coverImageUrl: element.previewFileToken,
              originImageUrl: element.orginalFileToken,
              recommendedDownloadMode: element.recommendedDownloadMode,
            ),
            diagnosisConclusion: element.diagnosisConclusion,
            diagnosisOrgans: element.diagnosisOrgans,
          ));
        });

        remedicalItems.add(RemedicalItemList(
          remedicalList: remedicalInfoList,
        ));
      } else if (source == VidImageSource.RemoteUS) {
        // 获取患者的病历记录
        PageResult<RemedicalListResult> result =
            PageResult<RemedicalListResult>();
        result.pageData = [];
        try {
          result = await RPCBridge.ins.rpc.remoteUltrasound
              .vitalGetRemedicalListPagesAsync(
            GetRecordsPageRequest(
              token: RPCBridge.ins.userToken,
              pageIndex: 1,
              pageSize: 100,
              patientCode: patientCode,
            ),
          );
        } catch (e) {
          logger.e('MeasureDataHelper vitalGetRemedicalListPagesAsync ex:$e');
        }
        // 遍历病历记录列表，当某条记录的 recordCode 与传入的 recordCode 相同时，将其 remedicalItemList 添加到 remedicalItems 中
        if (result.pageData!.isNotEmpty) {
          var recordInfo = result.pageData!.firstWhere(
              (element) => element.recordCode == recordCode,
              orElse: () => RemedicalListResult());
          remedicalItems = recordInfo.remedicalItemList ?? [];
        }
      }
      // 当数据来源为其他情况时
      else {
        // 获取患者的病历记录
        PageResult<RemedicalListResult> result =
            PageResult<RemedicalListResult>();
        result.pageData = [];
        try {
          result = await RPCBridge.ins.rpc.remedical.getRemedicalListPagesAsync(
            GetRecordsPageRequest(
              token: RPCBridge.ins.userToken,
              pageIndex: 1,
              pageSize: 100,
              patientCode: patientCode,
            ),
          );
        } catch (e) {
          logger.e('MeasureDataHelper getRemedicalListPagesAsync ex:$e');
        }
        // 遍历病历记录列表，当某条记录的 recordCode 与传入的 recordCode 相同时，将其 remedicalItemList 添加到 remedicalItems 中
        if (result.pageData!.isNotEmpty) {
          var recordInfo = result.pageData!.firstWhere(
              (element) => element.recordCode == recordCode,
              orElse: () => RemedicalListResult());
          remedicalItems = recordInfo.remedicalItemList ?? [];
        }
      }
      // 返回最终的 remedicalItems 列表
      return remedicalItems;
    } catch (e) {
      logger.e('MeasureHomeController getRemedicalList ex:', e);
      // 出现异常时返回空列表
      return [];
    }
  }

  ///获取会诊图像
  static Future<List<ConsultationImagesDTO>> getConsultationImages(
      String consultationCode) async {
    try {
      if (consultationCode.isEmpty) {
        return [];
      }
      var realTimeConsultationImageList =
          await RPCBridge.ins.rpc.liveConsultation.getConsultationFilesAsync(
        FindConsultationDetailRequest(
            consultationCode: consultationCode, token: RPCBridge.ins.userToken),
      );
      return realTimeConsultationImageList;
    } catch (e) {
      logger.e('RealTimeConsultationImageController getConsultationImages ex:' +
          e.toString());
    }
    return [];
  }

  ///获取图像详情
  static Future<RemedicalInfoDTO?> getImageInfo(
    String remedicalCode,
    String? remedicalAISelectedInfoCode,
  ) async {
    try {
      RemedicalInfoDTO result;
      print(source);
      if (source == VidImageSource.AiResultModifier) {
        final remedicalAISelectedInfo =
            await RPCBridge.ins.rpc.remedical.getRemedicalAISelectedInfoAsync(
          GetRemedicalAISelectedInfoRequest(
            token: RPCBridge.ins.userToken,
            code: remedicalAISelectedInfoCode,
          ),
        );

        result = RemedicalInfoDTO(
          diagnosisResult: jsonEncode(
            [
              {
                'DiagResultsForEachOrgan':
                    jsonDecode(remedicalAISelectedInfo.diagnosisData ?? '')[
                        'DiagResultsForEachOrgan'],
                'Index': jsonDecode(
                    remedicalAISelectedInfo.diagnosisData ?? '')['Index'],
                'PriorityScore':
                    jsonDecode(remedicalAISelectedInfo.diagnosisData ?? '')[
                        'PriorityScore'],
              }
            ],
          ),
          terminalImages: TerminalImageDTO(
            previewUrl: remedicalAISelectedInfo.previewFileToken,
            imageUrl: remedicalAISelectedInfo.cdnFileToken,
            coverImageUrl: remedicalAISelectedInfo.previewFileToken,
            originImageUrl: remedicalAISelectedInfo.orginalFileToken,
            recommendedDownloadMode:
                remedicalAISelectedInfo.recommendedDownloadMode,
          ),
          diagnosisConclusion: DiagnosisConclusionEnum.Benign,
        );
      } else if (source == VidImageSource.RemoteUS) {
        result = await RPCBridge.ins.rpc.remoteUltrasound
            .vitalFindRemedicalByCodeAsync(
          FindRemedicalByCodeRequest(
            token: RPCBridge.ins.userToken,
            remedicalCode: remedicalCode,
            existDiagnosisResult: true,
          ),
        );
      } else {
        result = await RPCBridge.ins.rpc.remedical.findRemedicalByCodeAsync(
          FindRemedicalByCodeRequest(
            token: RPCBridge.ins.userToken,
            remedicalCode: remedicalCode,
            existDiagnosisResult: true,
          ),
        );
      }

      return result;
    } catch (e) {
      logger.e('MeasureHomeController getRemedicalInfo ex:', e);
      return null;
    }
  }

  ///获取测量项
  static Future<MeasureApplicationDTO?> getMeasureApplication(
      MeasureModeSelection args) async {
    try {
      final result =
          await RPCBridge.ins.rpc.remedical.getMeasureApplicationAsync(
        GetMeasureApplicationRequest(
          token: RPCBridge.ins.userToken,
          applicationName: args.applicationName,
          categoryName: args.categoryName,
          measureModes: args.measureModes,
        ),
      );
      return result;
    } catch (e) {
      print(e);
      logger.e('MeasureHomeController getMeasureApplication ex: ', e);
      return null;
    }
  }

  /// 保存测量的方法
  static Future<bool> saveUserDefinedMeasureApplicationAsync(
      MeasureModeSubmit args) async {
    var result = false;
    try {
      result = await RPCBridge.ins.rpc.remedical
          .saveUserDefinedMeasureApplicationAsync(
        SaveUserDefinedMeasureApplicationRequest(
          token: RPCBridge.ins.userToken,
          version: args.version,
          applicationName: args.applicationName,
          categoryName: args.categoryName,
          workingMode: args.workingMode,
        ),
      );
    } catch (e) {
      logger.e(
          'MeasureHomeController saveUserDefinedMeasureApplicationAsync ex: ',
          e);
    }
    return result;
  }

  /// 保存样式
  static Future<void> saveMeasureSystemSettingAsync(
    MeasureSystemSettingDTO measureSystemSetting,
  ) async {
    await RPCBridge.ins.rpc.remedical.saveMeasureSystemSettingAsync(
      SaveMeasureSystemSettingRequest(
        systemSetting: measureSystemSetting,
        token: RPCBridge.ins.userToken,
      ),
    );
  }

  /// 获取样式
  static Future<MeasureSystemSettingDTO> getMeasureSystemSettingAsync() async {
    final result =
        await RPCBridge.ins.rpc.remedical.getMeasureSystemSettingAsync(
      GetMeasureSystemSettingRequest(
        token: RPCBridge.ins.userToken,
      ),
    );
    return result;
  }

  /// 分享vid
  static Future<String> shareImage(
    String examFile,
  ) async {
    try {
      final result = await RPCBridge.ins.rpc.remedical.queryShareExamPageAsync(
        QueryShareExamPageRequest(
          examFileToken: examFile,
          token: RPCBridge.ins.userToken,
          languageCode: i18nBook.locale.toCodeString('-'),
        ),
      );
      return result.shareExamPageUrl ?? '';
    } catch (e) {
      logger.e("queryShareExamPageAsync exception:", e);
    }
    return '';
  }

  /// 获取注释
  static Future<CommentItemResultDTO?> getCommentsByApplicationAsync(
      String applicationName, String categoryName) async {
    try {
      final result =
          await RPCBridge.ins.rpc.remedical.getCommentsByApplicationAsync(
        GetCommentsByApplicationRequest(
          token: RPCBridge.ins.userToken,
          applicationName: applicationName,
          categoryName: categoryName,
          languageCode: i18nBook.locale.toCodeString('-'),
          // Store.app.systemLocale.languageCode.toLowerCase(),
        ),
      );
      return result;
    } catch (e) {
      logger.e('MeasureHomeController getCommentsByApplicationAsync ex: ', e);
      return null;
    }
  }

  /// 保存注释
  static Future<bool?> saveUserDefinedCommentsAsync(
    String applicationName,
    String categoryName,
    List<CommentItemDTO>? addCommentItems,
    List<CommentItemDTO>? deleteCommentItems,
    List<UpdateCommentItemDTO>? updateCommentItems,
  ) async {
    try {
      final result =
          await RPCBridge.ins.rpc.remedical.saveUserDefinedCommentsAsync(
        SaveUserDefinedCommentsRequest(
            token: RPCBridge.ins.userToken,
            applicationName: applicationName,
            categoryName: categoryName,
            languageCode: i18nBook.locale.toCodeString('-'),
            // Store.app.systemLocale.languageCode.toLowerCase(),
            addCommentItems: addCommentItems,
            deletedCommentItems: deleteCommentItems,
            updateCommentItems: updateCommentItems),
      );
      return result;
    } catch (e) {
      logger.e('MeasureHomeController getCommentsByApplicationAsync ex: ', e);
      return null;
    }
  }

  /// 重置注释
  static Future<bool?> resetUserCommentsAsync(
    String applicationName,
    String categoryName,
  ) async {
    try {
      final result = await RPCBridge.ins.rpc.remedical.resetUserCommentsAsync(
        ResetUserCommentsRequest(
          token: RPCBridge.ins.userToken,
          applicationName: applicationName,
          categoryName: categoryName,
        ),
      );
      return result;
    } catch (e) {
      logger.e('MeasureHomeController resetUserCommentsAsync ex: ', e);
      return null;
    }
  }

  /// 获取预置的注释项
  static Future<PresetCommentItemResultDTO?> getPresetCommentsAsync() async {
    try {
      final result = await RPCBridge.ins.rpc.remedical.getPresetCommentsAsync(
        GetPresetCommentsRequest(
          token: RPCBridge.ins.userToken,
          languageCode: i18nBook.locale.toCodeString('-'),
          // Store.app.systemLocale.languageCode.toLowerCase(),
        ),
      );
      return result;
    } catch (e) {
      logger.e('MeasureHomeController getPresetCommentsAsync ex: ', e);
      return null;
    }
  }

  static Future<RemedicalInfoDTO?> getImageInfoByIndex(
      String recordCode, String token, String patientCode, int index) async {
    var imageList = await getRemedicalList(patientCode, recordCode);
    int imageIndex = 0;
    for (RemedicalItemList r in imageList) {
      for (RemedicalInfoDTO i in r.remedicalList ?? []) {
        imageIndex++;
        if (imageIndex == index) {
          return i;
        }
      }
    }
    return null;
  }
}