fis_lib_measure/lib/process/primitives/utils/urm_sharp_copy.dart

import 'package:fis_common/event/event_type.dart';
import 'package:fis_measure/interfaces/date_types/point.dart';

enum UrmSharpCopyDataType {
  rect,
  trace,
  ellipse,
  rim,
}

class UrmSharpCopyActiveState {
  final UrmSharpCopyDataType type;
  final int index;

  UrmSharpCopyActiveState(this.type, this.index);
}

class UrmSharpCopyBoard {
  UrmSharpCopyBoard._();

  static final _ins = UrmSharpCopyBoard._();

  static UrmSharpCopyActiveState? activeState;

  static final typeCacheChanged = FEventHandler<UrmSharpCopyDataType>();
  static final activeStateChanged = FEventHandler<UrmSharpCopyActiveState?>();

  static final _cacheMap = <UrmSharpCopyDataType, List<UrmSharpCopyData>>{};

  static List<UrmSharpCopyData> getCachedList(UrmSharpCopyDataType type) {
    final list = _findCacheListByType(type);
    return list;
  }

  static void recordSharp(UrmSharpCopyDataType type, List<DPoint> points) {
    final arr = points.map((e) => e.clone()).toList();
    UrmSharpCopyData data = UrmSharpCopyData.create(type, arr);

    final list = _findCacheListByType(type);
    if (list.length == 2) {
      final left = list.last;
      list.clear();
      list.add(left);
    }
    list.add(data);
    typeCacheChanged.emit(_ins, type);
  }

  static List<UrmSharpCopyData> _findCacheListByType(
      UrmSharpCopyDataType type) {
    if (!_cacheMap.containsKey(type)) {
      _cacheMap[type] = [];
    }
    return _cacheMap[type]!;
  }

  static switchActiveState(UrmSharpCopyActiveState? state) {
    activeState = state;
    activeStateChanged.emit(_ins, state);
  }
}

class RectUrmSharpCopyData extends UrmSharpCopyData {
  RectUrmSharpCopyData(super.type, super.points);
}

class TraceUrmSharpCopyData extends UrmSharpCopyData {
  TraceUrmSharpCopyData(super.type, super.points);
}

class EllipseUrmSharpCopyData extends UrmSharpCopyData {
  EllipseUrmSharpCopyData(super.type, super.points);
}

class RimUrmSharpCopyData extends UrmSharpCopyData {
  RimUrmSharpCopyData(super.type, super.points);
}

class UrmSharpCopyData {
  final UrmSharpCopyDataType type;
  final List<DPoint> points;

  UrmSharpCopyData(this.type, this.points);

  static UrmSharpCopyData create(
      UrmSharpCopyDataType type, List<DPoint> points) {
    switch (type) {
      case UrmSharpCopyDataType.rect:
        return RectUrmSharpCopyData(type, points);
      case UrmSharpCopyDataType.trace:
        return TraceUrmSharpCopyData(type, points);
      case UrmSharpCopyDataType.ellipse:
        return EllipseUrmSharpCopyData(type, points);
      case UrmSharpCopyDataType.rim:
        return RimUrmSharpCopyData(type, points);
    }
  }
}