fis_lib_measure/lib/process/primitives/combos/lv_study.dart

import 'package:fis_measure/interfaces/date_types/point.dart';
import 'package:fis_measure/interfaces/enums/items.dart';
import 'package:fis_measure/interfaces/process/items/item.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/point_info.dart';
import 'package:fis_measure/process/calcuators/distance.dart';
import 'package:fis_measure/process/calcuators/lv_study.dart';
import 'package:fis_measure/process/calcuators/time_motion.dart';
import 'package:fis_measure/process/items/top_item.dart';
import 'package:fis_measure/process/items/top_item_feature.dart';
import 'package:fis_measure/process/primitives/straightline.dart';
import 'package:fis_measure/view/gesture/cross_position_indicator.dart';

class LvStudy extends TopMeasureItem<StraightLineGroupFeature> {
  static final _dItemNames = [
    MeasureTerms.IVSd,
    MeasureTerms.LVIDd,
    MeasureTerms.LVPWd,
  ];
  static final _sItemNames = [
    MeasureTerms.IVSs,
    MeasureTerms.LVIDs,
    MeasureTerms.LVPWs,
  ];

  final bool ifVertical;
  final bool ifTimeSpan;

  late final List<StraightLine> _dChildItems = [];
  late final List<StraightLine> _sChildItems = [];
  DPoint? _dPoint;
  DPoint? _sPoint;
  IMeasureItem? _lastChild;

  LvStudy(ItemMeta meta, {this.ifVertical = false, this.ifTimeSpan = false})
      : super(meta) {
    for (final childMeta in meta.childItems) {
      _LvStudyStraightLine childItem;
      if (childMeta.measureType == "VerticalDistance") {
        // measureType
        // childItem = StraightLine.createVerticalDistance(childMeta, this);
        childItem = _LvStudyStraightLine(childMeta, this);
        childItem.calculator = VerticalDistanceCal(childItem);
        childItem.ifVertical = true;
      } else if (ifTimeSpan) {
        childItem = _LvStudyStraightLine(childMeta, this);
        childItem.calculator = TimeSpanCal(childItem);
      } else {
        childItem = _LvStudyStraightLine(childMeta, this);
        childItem.calculator = DistanceCal(childItem);
      }
      childItems.add(childItem);

      if (_dItemNames.contains(childMeta.name)) {
        _dChildItems.add(childItem);
      }
      if (_sItemNames.contains(childMeta.name)) {
        _sChildItems.add(childItem);
      }
    }

    workingChildChanged.addListener(_onWorkingChildChanged);
  }

  @override
  bool get finishAfterUnactive => true;

  @override
  bool get isCrossFrameMode => true;

  @override
  StraightLineGroupFeature buildFeature() => StraightLineGroupFeature(this);

  static LvStudy createLvStudyByLineGroup(ItemMeta meta,
      [IMeasureItem? parent]) {
    if (![
      MeasureTypes.LvStudyByLineGroup,
      MeasureTypes.LvStudyByLineGroupTissue
    ].contains(meta.measureType)) {
      throw ArgumentError();
    }
    var ins = LvStudy(meta);
    ins.calculator = LvStudyDistanceGroupCal(ins);

    return ins;
  }

  static LvStudy createLvSimpleTissue(ItemMeta meta, [IMeasureItem? parent]) {
    var ins = LvStudy(meta);
    ins.calculator = LvStudySimpleCal(ins);
    return ins;
  }

  static LvStudy createLvSimpleTissueTm(ItemMeta meta, [IMeasureItem? parent]) {
    var ins = LvStudy(
      meta,
      ifTimeSpan: true,
      ifVertical: true,
    );
    ins.calculator = LvStudySimpleCal(ins);
    return ins;
  }

  void _onWorkingChildChanged(_, int e) {
    // final isMBelow =
    //     ["m", "pw"].contains(application.currentMode.name.toLowerCase());
    // if (!isMBelow) {
    //   return;
    // }

    if (_lastChild != null) {
      _lastChild!.onItemStatesChanged.removeListener(_onChildItemStatesChanged);
    }
    workingChild.onItemStatesChanged.addListener(_onChildItemStatesChanged);
    _lastChild = workingChild;

    final childItem = workingChild as _LvStudyStraightLine;
    if (_dChildItems.contains(childItem)) {
      final point = _findDPoint(childItem);
      if (point != null) {
        final offset = point.toOffset();
        final pointInfo = PointInfo.fromOffset(offset, PointInfoType.mouseDown);
        pointInfo.hostVisualArea = application.currentVisualArea;
        childItem.refPoint = pointInfo;
        childItem.execute(pointInfo);
      }
    }
    if (_sChildItems.contains(childItem)) {
      final point = _findSPoint(childItem);
      if (point != null) {
        final offset = point.toOffset();
        final pointInfo = PointInfo.fromOffset(offset, PointInfoType.mouseDown);
        pointInfo.hostVisualArea = application.currentVisualArea;
        childItem.refPoint = pointInfo;
        childItem.execute(pointInfo);
      }
    }
  }

  void _onChildItemStatesChanged(_, ItemStates? e) {
    final childItem = workingChild as StraightLine;
    if (e == ItemStates.finished && childItem.measuredFeatures.isNotEmpty) {
      final feature = childItem.measuredFeatures.first;
      final point = feature.endPoint;
      if (_dChildItems.contains(childItem)) {
        _dPoint = point;
      }
      if (_sChildItems.contains(childItem)) {
        _sPoint = point;
      }
    }
  }

  void _onChildItemMeasured() {
    final childItem = workingChild as _LvStudyStraightLine;
    if (_dChildItems.contains(childItem)) {
      _handleDChildMeasured(childItem);
    }
    if (_sChildItems.contains(childItem)) {
      _handleSChildMeasured(childItem);
    }
  }

  void _handleDChildMeasured(_LvStudyStraightLine childItem) {
    childItem.changeCrossIndicatorStyle(CrossIndicatorStyle.horizontal);
  }

  void _handleSChildMeasured(_LvStudyStraightLine childItem) {
    childItem.changeCrossIndicatorStyle(CrossIndicatorStyle.horizontal);
  }

  DPoint? _findDPoint(_LvStudyStraightLine item) =>
      _findPointFromItems(_dChildItems, item);
  DPoint? _findSPoint(_LvStudyStraightLine item) =>
      _findPointFromItems(_sChildItems, item);

  DPoint? _findPointFromItems(
      List<StraightLine> items, _LvStudyStraightLine currItem) {
    final lastIndex = workingChildIndex - 1;
    if (lastIndex < 0) {
      return null;
    }
    final lastItem = childItems[lastIndex];
    if (items.contains(lastItem)) {
      if (lastItem.measuredFeatures.isNotEmpty) {
        final feature = (lastItem as StraightLine).measuredFeatures.first;
        final point =
            currItem.ifVertical ? feature.startPoint : feature.endPoint;
        return point;
      }
    }
    return null;
  }
}

class StraightLineGroupFeature extends TopMeasureItemFeature {
  StraightLineGroupFeature(
    ITopMeasureItem refItem,
  ) : super(refItem);
}

class _LvStudyStraightLine extends StraightLine {
  _LvStudyStraightLine(super.meta, super.parent);

  DPoint? refPoint;
  bool ifVertical = false;

  @override
  bool onExecuteMouse(PointInfo args) {
    if (ifVertical && refPoint != null) {
      args.x = refPoint!.x;
    }
    return super.onExecuteMouse(args);
  }
}