import 'dart:ui';

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/workspace/point_info.dart';
import 'package:fis_measure/process/calcuators/carotid_imt.dart';
import 'package:fis_measure/process/items/item.dart';
import 'package:fis_measure/utils/canvas.dart';

import '../items/item_feature.dart';

class CarotidIMT extends MeasureItem<CarotidIMTFeature> {
  CarotidIMT(ItemMeta meta, IMeasureItem? parent) : super(meta, parent);

  static CarotidIMT createMeasureRect(ItemMeta meta, [IMeasureItem? parent]) {
    CarotidIMT measureRect = CarotidIMT(meta, parent);
    measureRect.calculator = CarotidCal(measureRect, meta.name);
    return measureRect;
  }

  @override
  bool onExecuteMouse(PointInfo args) {
    if (state == ItemStates.finished) {
      if (args.pointType == PointInfoType.mouseDown) {
        state = ItemStates.waiting;
      }
    }

    if (state == ItemStates.waiting) {
      if (args.pointType == PointInfoType.mouseDown) {
        handleMouseDownWhileWaiting(args);
      }
    } else if (state == ItemStates.running) {
      if (args.pointType == PointInfoType.mouseUp) return false;

      feature?.endPoint = args;
      if (args.pointType == PointInfoType.mouseDown) {
        doCalculate();

        feature!.isActive = false;
        state = ItemStates.finished;

        ///TODO 能否可以不加 delay，直接执行（此处是为了 cal 内 ref.feature!.lowerPoints = lowerPoints; 能够执行完成）
        Future.delayed(const Duration(milliseconds: 500), () {
          doFeatureFinish();
        });
      }
    }
    return true;
  }

  @override
  bool onExecuteTouch(PointInfo args) {
    // TODO: implement onExecuteTouch
    throw UnimplementedError();
  }

  void handleMouseDownWhileWaiting(PointInfo args) {
    // TODO: 判断是否当前area
    // 转换为Area逻辑位置
    final point = args.toAreaLogicPoint();
    feature = CarotidIMTFeature(this, point, point);
    if (args.hostVisualArea != null) {
      feature!.hostVisualArea = args.hostVisualArea;
    }
    state = ItemStates.running;
  }
}

class CarotidIMTFeature extends MeasureItemFeature {
  CarotidIMTFeature(
    IMeasureItem refItem,
    DPoint startPoint,
    DPoint endPoint,
  ) : super(refItem) {
    innerPoints.add(startPoint);
    innerPoints.add(endPoint);
  }

  /// 起点
  DPoint get startPoint => innerPoints[0];
  set startPoint(DPoint value) => innerPoints[0] = value;

  /// 终点
  DPoint get endPoint => innerPoints[1];
  set endPoint(DPoint value) => innerPoints[1] = value;

  List<List<Offset>> offsetsList = [];
  List<List<Offset>> scaledOffsetsList = [];

  @override
  void paint(Canvas canvas, Size size) {
    if (startPoint == endPoint) return;
    drawId(canvas, size, idText);

    final startOffset = convert2ViewPoint(size, startPoint).toOffset();
    drawVertex(canvas, startOffset);

    final endOffset = convert2ViewPoint(size, endPoint).toOffset();
    canvas.drawDashRect(startOffset, endOffset, 1, 10, paintPan);
    drawVertex(canvas, endOffset, isActive);
    //绘制点集连线
    scaledOffsetsList = offsetsList.map((e) {
      return e.map((e) {
        return e * refItem.scaleRatio;
      }).toList();
    }).toList();
    for (var offsets in scaledOffsetsList) {
      canvas.drawPointsLine(offsets, paintLinePan);
    }
  }
}