fis_lib_measure/lib/view/measure/measure_view.dart

import 'package:fis_i18n/i18n.dart';
import 'package:fis_jsonrpc/rpc.dart';
import 'package:fis_measure/interfaces/enums/annotation.dart';
import 'package:fis_measure/interfaces/process/player/play_controller.dart';
import 'package:fis_measure/interfaces/process/workspace/application.dart';
import 'package:fis_measure/interfaces/process/workspace/exam_info.dart';
import 'package:fis_measure/interfaces/process/workspace/measure_3d_view_controller.dart';
import 'package:fis_measure/process/language/measure_language.dart';
import 'package:fis_measure/process/layout/configuration.dart';
import 'package:fis_measure/process/workspace/measure_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/process/workspace/measure_3d_view_controller.dart';
import 'package:fis_measure/view/cursor.dart';
import 'package:fis_measure/view/gesture/positioned_cursor.dart';
import 'package:fis_measure/view/measure/measure_images_bar.dart';
import 'package:fis_measure/view/measure/measure_left_annotation.dart';
import 'package:fis_measure/view/measure/measure_player.dart';
import 'package:fis_measure/view/measure/measure_search_input.dart';
import 'package:fis_measure/view/measure/measure_tool.dart';
import 'package:fis_measure/view/measure/carotid_measure_tool.dart';
import 'package:fis_measure/view/measure/measure_tools_title.dart';
import 'package:fis_measure/view/measure/measure_view_controller.dart';
import 'package:fis_measure/view/measure/tool_chest_title.dart';
import 'package:fis_measure/view/player/control_board/operate_bar.dart';
import 'package:fis_ui/index.dart';

import 'package:flutter/material.dart';
import 'package:get/get.dart';

/// 测量主页面
class MeasureMainPage extends StatefulWidget implements FWidget {
  const MeasureMainPage(
      this.token, this.recordCode, this.patientCode, this.remedicalCode,
      {Key? key})
      : super(key: key);

  final String token;
  final String patientCode;
  final String remedicalCode;
  final String recordCode;

  @override
  State<StatefulWidget> createState() => _MeasureMainPageState();
}

class _MeasureMainPageState extends State<MeasureMainPage> {
  /// 数据
  final measureData = Get.find<MeasureDataController>();

  /// webview 控制器
  final measure3DViewController = Get.find<Measure3DViewController>();

  final mouseState = Get.put<IMouseState>(MouseState());

  /// 测量项控制器
  final measureMetaController = Get.put(MeasureMetaController());

  /// 页面loadding
  bool loaded = false;

  // /// 图片loadding
  late bool imageLoaded = false;

  ///检查图片信息表
  List<ExamImageInfo> examImageInfoList = [];

  late final measureHandler = Get.find<MeasureHandler>();

  /// 测量控制器
  late MeasureController measureController = Get.put(MeasureController(
    "",
    imagesFetchFunc: (code) async {
      return examImageInfoList;
    },
  ));

  /// 获取测量图片所需的图片组 并且写入控制器中 加载
  void getExamImageInfoList(List<RemedicalInfoDTO> remedicals) async {
    for (var element in remedicals) {
      examImageInfoList.add(
        ExamImageInfo(
          element.terminalImages!.imageUrl!,
          element.terminalImages!.previewUrl!,
        ),
      );
    }

    measureController = Get.put(MeasureController(
      "",
      imagesFetchFunc: (code) async {
        return examImageInfoList;
      },
    ));

    await measureController.load();
    int selectedImageIndex = -1;
    if (examImageInfoList
        .any((element) => element.url == measureData.itemCurrentImage)) {
      ExamImageInfo selectedImage = examImageInfoList.firstWhere(
        (element) => element.url == measureData.itemCurrentImage,
      );
      selectedImageIndex = examImageInfoList.indexOf(selectedImage);
      measureController.examInfo.selectedImageIndex = selectedImageIndex;
    }
    MeasureLanguage.load(measureData.measureLanguage);
  }

  void changeImage(sender, e) {
    imageLoaded = e;
    setState(() {});
  }

  void changeFullScreenState(sender, e) {
    setState(() {});
  }

  @override
  void initState() {
    loadLayoutConfig();
    getImageInfo();
    measureHandler.onChangeImageLoaded.addListener(changeImage);
    measureHandler.onChangeFullScreenState.addListener(changeFullScreenState);
    super.initState();
  }

  void getImageInfo() {
    measureData.measureImageData = MeasureImageData(
      patientCode: widget.patientCode,
      recordCode: widget.recordCode,
      remedicalCode: widget.remedicalCode,
    );
  }

  /// 加载图像布局配置
  void loadLayoutConfig() async {
    await LayoutConfiguration.ins.loadData();
    setState(() {
      // 加载图像数据
      _initData();
    });
  }

  void onImageLoaded(Object sender, ExamImageInfo? e) async {
    // measureHandler.changeImageLoaded = true;
    if (!mounted) return;
    final currentImage = measureData.remedicalList.firstWhereOrNull(
      (element) => element.terminalImages!.imageUrl == e!.url,
    );
    if (currentImage != null) {
      /// 获取图片详细信息
      var remedicalInfo = await measureData.getImageInfo(
        currentImage.remedicalCode ?? '',
        widget.token,
      );
      if (remedicalInfo != null) {
        measureData.aiResults = remedicalInfo.diagnosisResult ?? '';
        measure3DViewController.initParams();

        /// ai 良恶性 判断是否有ai
        measureData.diagnosisConclusion = remedicalInfo.diagnosisConclusion;
        if (remedicalInfo.carotidResult != null) {
          /// [Carotid] ✅详情传入测量信息
          measure3DViewController.carotidResult = remedicalInfo.carotidResult!;

          /// [Carotid] ✅需要在此通知 controller 存在颈动脉信息
          measure3DViewController.exist3DData = true;
          measure3DViewController
              .handleChangeCarotid2DImage(remedicalInfo.recordCode!);
        } else {
          measure3DViewController.exist3DData = false;
        }
        // [Carotid] ✅只要更换图片都要切换到Vid 2D模式
        measure3DViewController.backToVidMode();
        try {
          if (e != null) {
            Future.delayed(const Duration(milliseconds: 100), () {
              measureController.playerController.play();
            });
            setState(() {
              loaded = true;
              measureHandler.changeImageLoaded = false;
            });
          }
        } catch (error) {
          setState(() {
            loaded = true;
            measureHandler.changeImageLoaded = false;
          });
        }
      }
    }
  }

  @override
  void dispose() {
    measureHandler.onChangeImageLoaded.removeListener(changeImage);
    measureHandler.onChangeFullScreenState
        .removeListener(changeFullScreenState);
    super.dispose();
  }

  @override
  FWidget build(BuildContext context) {
    FWidget body;
    if (!loaded) {
      const loadingWidget = FCenter(child: FCircularProgressIndicator());
      body = FRow(
        children: const [
          FExpanded(
            child: loadingWidget,
          ),
        ],
      );
    } else {
      body = FRow(
        children: [
          if (!measureHandler.fullScreenState) _MeasureLeftBoard(),
          const FVerticalDivider(),
          FExpanded(
            child: FColumn(
              mainAxisSize: MainAxisSize.max,
              children: [
                FExpanded(
                    child: FStack(
                  children: [
                    if (!imageLoaded)
                      MeasureRightBoard(
                        key: ValueKey(measureData.itemCurrentImage),
                      ),
                    if (imageLoaded)
                      const FCenter(
                        child: FCircularProgressIndicator(),
                      ),
                  ],
                )),
                if (!measureHandler.fullScreenState) const MeasureImagesBar(),
              ],
            ),
          ),
        ],
      );
    }

    return FCenter(
      child: FContainer(
        color: const Color.fromRGBO(70, 70, 70, 1),
        child: body,
      ),
    );
  }

  MeasureCursorType _getMeasureSystemSettingCursorType(
    CursorTypeEnum cursorType,
  ) {
    switch (cursorType) {
      case CursorTypeEnum.CursorType1Icon:
        return MeasureCursorType.cursor01;
      case CursorTypeEnum.CursorType2Icon:
        return MeasureCursorType.cursor02;
      case CursorTypeEnum.CursorType3Icon:
        return MeasureCursorType.cursor03;
      case CursorTypeEnum.CursorType4Icon:
        return MeasureCursorType.cursor04;
      case CursorTypeEnum.CursorType5Icon:
        return MeasureCursorType.cursor05;
      default:
        return MeasureCursorType.cursor01;
    }
  }

  /// 初始化卡尺样式部分
  Future<void> _getMeasureSystemSetting() async {
    final result = await measureData.getMeasureSystemSettingAsync();
    measureData.measureSystemSetting = result as MeasureSystemSettingDTO;
    mouseState.cursorType = MeasureCursorType.cursor01;
    mouseState.cursorSize = 16.0;
  }

  void _initData() async {
    List<RemedicalInfoDTO> remedicals = [];
    List<Ultra3DResourceInfo> ultra3DResourceInfos = [];
    loaded = false;

    var value = await measureData.getRemedicalList.call(
      widget.patientCode,
      widget.recordCode,
      widget.token,
    );

    for (var remedicalItemList in value) {
      remedicals.addAll(remedicalItemList.remedicalList ?? []);
    }

    /// 获取样式
    _getMeasureSystemSetting();

    /// [Carotid] ✅遍历出颈动脉信息列表,传给壳子
    for (var remedical in remedicals) {
      if (remedical.carotidResult != null) {
        ultra3DResourceInfos.add(Ultra3DResourceInfo(remedical.carotidResult!));
      }
    }
    measure3DViewController.ultra3DResourceInfoList = ultra3DResourceInfos;
    measure3DViewController.recordId = widget.recordCode;
    measure3DViewController.notifyShellLoadAllModel();
    measureData.remedicalList = remedicals;
    var remedicalInfo =
        await measureData.getImageInfo.call(widget.remedicalCode, widget.token);
    if (remedicalInfo != null) {
      measureData.aiResults = remedicalInfo.diagnosisResult ?? '';

      if (remedicalInfo.terminalImages != null) {
        loaded = true;
        measureData.itemCurrentImage =
            remedicalInfo.terminalImages!.imageUrl ?? '';
        getExamImageInfoList(remedicals);
      }
    }

    measureController.imageLoaded.removeListener(onImageLoaded);
    measureController.imageLoaded.addListener(onImageLoaded);
  }
}

/// 测量左边操作页面
class _MeasureLeftBoard extends StatefulWidget implements FWidget {
  @override
  State<_MeasureLeftBoard> createState() => _MeasureLeftBoardState();
}

class _MeasureLeftBoardState extends State<_MeasureLeftBoard> {
  final measureHandler = Get.find<MeasureHandler>();
  final playerController = Get.find<IPlayerController>();
  final measure3DViewController = Get.find<Measure3DViewController>();

  /// 数据
  late final measureData = Get.find<MeasureDataController>();

  /// 测量项控制器
  final measureMetaController = Get.find<MeasureMetaController>();

  /// 是否显示颈动脉2D指定的测量项
  bool showCarotid2DSelectMeasure = false;

  /// 是否显示测量项
  bool showMeasureItems = true;

  bool isMeasureTool = true;
  bool get isArrowMeasureAnnotationType =>
      measureHandler.changedAnnotationType == AnnotationType.arrow;
  void _onChangedTab(
    Object sender,
    TagEnum? e,
  ) {
    if (e == TagEnum.MeasureTool) {
      measureMetaController.setAvailableModes(measureData.currentMode);
      measureMetaController.updateItemList();
      // application.currentOperateType = MeasureOperateType.measure;
    } else {
      final application = Get.find<IApplication>();
      application.switchAnnotation(
          AnnotationType.label, measureData.getCommentsList[0]);
    }
    setState(() {});
  }

  void _onCurItemMetaListChanged(sender, e) {
    if (mounted) {
      setState(() {});
    }
  }

  @override
  void initState() {
    measureHandler.onChangedTab.addListener(_onChangedTab);
    measure3DViewController.updatePlayerMode.addListener(_onModeChanged);
    measureData.curItemMetaListChanged.addListener(_onCurItemMetaListChanged);

    super.initState();
  }

  @override
  void dispose() {
    measureHandler.onChangedTab.removeListener(_onChangedTab);
    measure3DViewController.updatePlayerMode.removeListener(_onModeChanged);
    measureData.curItemMetaListChanged
        .removeListener(_onCurItemMetaListChanged);

    super.dispose();
  }

  /// 模式改变触发更新
  void _onModeChanged(Object s, MeasureMode mode) {
    switch (mode) {
      case MeasureMode.vidMode:
        setState(() {
          showCarotid2DSelectMeasure = false;
          showMeasureItems = true;
        });
        break;
      case MeasureMode.carotid2DMode:
        setState(() {
          showCarotid2DSelectMeasure = true;
          showMeasureItems = true;
        });
        break;
      case MeasureMode.carotid3DMode:
        setState(() {
          showCarotid2DSelectMeasure = true;
          showMeasureItems = false;
        });
        break;
    }
  }

  @override
  FWidget build(BuildContext context) {
    return FColumn(
      mainAxisSize: MainAxisSize.max,
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        if (showMeasureItems) ...[
          LeftSiderHold(ifHideConfig: showCarotid2DSelectMeasure)
        ],
        if (!(measureHandler.changedTab == TagEnum.MeasureTool)) ...[
          FContainer(
            width: 300,
            key: UniqueKey(),
            child: LeftSelectInput(),
          ),
          FExpanded(
            child: FContainer(
              width: 300,
              key: UniqueKey(),
              child: const MeasureLeftAnnotation(),
            ),
          ),
          _MeasureArrow(),
        ] else ...[
          if (showMeasureItems) ...[const LeftMeasureTools()],
          FExpanded(
            child: showMeasureItems
                ? FContainer(
                    width: 300,
                    child: showCarotid2DSelectMeasure
                        ? const CarotidLeftSiderSelectMeasure()
                        : const LeftSiderSelectMeasure(),
                  )
                : FContainer(),
          ),
          const OperateBar(),
        ]
      ],
    );
  }
}

class _MeasureArrow extends FStatefulWidget {
  @override
  FState<_MeasureArrow> createState() => _MeasureArrowState();
}

class _MeasureArrowState extends FState<_MeasureArrow> {
  final measureHandler = Get.find<MeasureHandler>();

  bool get isArrowMeasureAnnotationType =>
      measureHandler.changedAnnotationType == AnnotationType.arrow;

  void onChangedAnnotationType(
    Object sender,
    AnnotationType? e,
  ) {
    setState(() {});
  }

  @override
  void initState() {
    measureHandler.onChangedAnnotationType.addListener(onChangedAnnotationType);
    super.initState();
  }

  @override
  void dispose() {
    measureHandler.onChangedAnnotationType
        .removeListener(onChangedAnnotationType);
    super.dispose();
  }

  @override
  FWidget build(BuildContext context) {
    return FContainer(
      height: 100,
      width: 300,
      child: FCenter(
        child: FColumn(
          children: [
            FInk(
              child: FInkWell(
                onTap: () {
                  measureHandler.changedAnnotationType = AnnotationType.arrow;
                  final application = Get.find<IApplication>();
                  application.switchAnnotation(AnnotationType.arrow);
                },
                child: FIcon(
                  Icons.call_made_rounded,
                  color:
                      isArrowMeasureAnnotationType ? Colors.blue : Colors.white,
                  size: 30,
                ),
              ),
            ),
            FText(
              i18nBook.measure.arrow.t,
              style: isArrowMeasureAnnotationType
                  ? const TextStyle(
                      color: Colors.blue,
                      fontSize: 14,
                    )
                  : const TextStyle(
                      color: Colors.white,
                      fontSize: 14,
                    ),
            ),
          ],
        ),
      ),
    );
  }
}