import 'dart:ui';

import 'package:fis_jsonrpc/rpc.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/workspace/point_info.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_rect_den_measure.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_rect_den_vel_measure.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_rect_density.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_rect_fractal_dim.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_rect_hist.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_rect_perfusion.dart';
import 'package:fis_measure/process/calcuators/urm_calcuators/urm_rect_vel_measure.dart';
import 'package:fis_measure/process/items/item.dart';
import 'package:fis_measure/utils/canvas.dart';
import 'package:fis_measure/utils/prompt_box.dart';
import 'dart:ui' as ui;

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

class URMRectMeasure extends MeasureItem<URMRectFeature> {
  URMRectMeasure(ItemMeta meta, IMeasureItem? parent) : super(meta, parent);
  static bool needPerfusion = false;

  static URMRectMeasure createMeasureRect(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMRectMeasure measureRect = URMRectMeasure(meta, parent);
    // measureRect.calculator = URMRectCal(measureRect, );
    return measureRect;
  }

  static URMRectMeasure createURMRectDensity(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMRectMeasure measureRect = URMRectMeasure(meta, parent);
    measureRect.calculator = URMRectDensityCal(
      measureRect,
    );
    return measureRect;
  }

  static URMRectMeasure createURMRectFractalDim(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMRectMeasure measureRect = URMRectMeasure(meta, parent);
    measureRect.calculator = URMRectFractalDimCal(
      measureRect,
    );
    return measureRect;
  }

  static URMRectMeasure createURMRectDenMeasure(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMRectMeasure measureRect = URMRectMeasure(meta, parent);
    measureRect.calculator = URMRectDenMeasureCal(
      measureRect,
    );
    return measureRect;
  }

  static URMRectMeasure createURMRectPerfusion(ItemMeta meta,
      [IMeasureItem? parent]) {
    needPerfusion = true;
    URMRectMeasure measureRect = URMRectMeasure(meta, parent);
    measureRect.calculator = URMRectPerfusionCal(
      measureRect,
    );
    return measureRect;
  }

  static URMRectMeasure createURMRectHist(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMRectMeasure measureRect = URMRectMeasure(meta, parent);
    measureRect.calculator = URMRectHistCal(
      measureRect,
    );
    return measureRect;
  }

  static URMRectMeasure createURMRectDenVelMeasure(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMRectMeasure measureRect = URMRectMeasure(meta, parent);
    measureRect.calculator = URMRectDenVelMeasureCal(
      measureRect,
    );
    return measureRect;
  }

  static URMRectMeasure createURMRectVelMeasure(ItemMeta meta,
      [IMeasureItem? parent]) {
    URMRectMeasure measureRectVel = URMRectMeasure(meta, parent);
    measureRectVel.calculator = URMRectVelMeasureCal(
      measureRectVel,
    );
    return measureRectVel;
  }

  @override
  bool onExecuteMouse(PointInfo args) {
    if (waitingResult) return false;
    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) {
        handleFinish();
      }
    }
    return true;
  }

  bool waitingResult = false;

  void handleFinish() async {
    feature!.isActive = false;
    PromptBox.loading("计算中...");
    waitingResult = true;
    await doCalculateAsync();
    doFeatureFinish();
    PromptBox.dismiss();
    waitingResult = false;
  }

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

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

    state = ItemStates.running;
  }
}

class URMRectFeature extends MeasureItemFeature {
  URMRectFeature(
    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 offsetsList) {
      canvas.drawPointsLine(offsets, paintLinePan);
    }
  }
}

class RectPerfusionImageFeature extends URMRectFeature {
  RectPerfusionImageFeature(
    IMeasureItem refItem,
    DPoint startPoint,
    DPoint endPoint,
  ) : super(refItem, startPoint, endPoint);

  ui.Image? perfusionImg;
  IntRect? perfusionPiexlRect;
  Rect? perfusionScaleDRect;
  @override
  void paint(Canvas canvas, Size size) {
    if (perfusionImg != null) {
      Paint paint = Paint();

      Rect src = Rect.fromLTWH(
        0,
        0,
        perfusionImg!.width.toDouble(),
        perfusionImg!.height.toDouble(),
      );
      Rect dst = Rect.fromLTWH(
        perfusionScaleDRect!.left.toDouble() * size.width,
        perfusionScaleDRect!.top.toDouble() * size.height,
        perfusionScaleDRect!.width.toDouble() * size.width,
        perfusionScaleDRect!.height.toDouble() * size.height,
      );
      canvas.drawImageRect(perfusionImg!, src, dst, paint);
    }
    super.paint(canvas, size);
  }
}