import 'package:fis_measure/interfaces/process/calculators/values.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/calculator.dart';
import 'package:fis_measure/process/items/factory.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/area_abstract.dart';
import 'package:fis_measure/process/primitives/straightline.dart';
import 'package:vid/us/vid_us_unit.dart';

class AreaStraightLine extends TopMeasureItem<AreaStraightLineFeature> {
  late final AreaItemAbstract area;
  late final StraightLine line;

  AreaStraightLine(ItemMeta meta) : super(meta) {
    final metaArea = meta.childItems.firstWhere(
        (e) => e.measureType.startsWith(MeasureTypes.AreaPerimeter));
    final metaLine = meta.getChildByType(MeasureTypes.Distance)!;
    area = MeasureItemFactory.createItem(metaArea, this) as AreaItemAbstract;
    line = StraightLine.createDistance(metaLine, this);
    childItems.add(area);
    childItems.add(line);
  }

  @override
  bool onExecuteMouse(PointInfo args) {
    if (args.pointType == PointInfoType.mouseDown) {
      if (feature == null) {
        feature = AreaStraightLineFeature(this);
        listenChildrenUpdate();
      }
      if (childrenAllDone) {
        workingChild.clear();
      }
    }
    feature?.hostVisualArea = args.hostVisualArea;
    final result = workingChild.execute(args);
    if (result) {
      doCalculate();
    }
    return result;
  }

  @override
  bool onExecuteTouch(PointInfo args) {
    return workingChild.execute(args);
  }

  static AreaStraightLine createVolume(ItemMeta meta, [IMeasureItem? parent]) {
    if (meta.measureType != MeasureTypes.AreaStraightLine) {
      throw ArgumentError();
    }
    final areaStraightLine = AreaStraightLine(meta);
    areaStraightLine.calculator = AreaStraightLineVolumeCal(areaStraightLine);
    return areaStraightLine;
  }
}

class AreaStraightLineFeature extends TopMeasureItemFeature {
  AreaStraightLineFeature(
    AreaStraightLine refItem,
  ) : super(refItem);
}

class AreaStraightLineVolumeCal extends Calculator<AreaStraightLine, double> {
  AreaStraightLineVolumeCal(AreaStraightLine ref) : super(ref);

  @override
  void calculate() {
    if (ref.feature == null) return;

    final areaFeature = findChildFeature<AreaItemFeatureAbstract>(ref.area);
    final lineFeature = findChildFeature<StraightLineFeature>(ref.line);
    if (areaFeature == null || lineFeature == null) return;

    final feature = ref.feature!;

    double area = 0;
    for (var value in areaFeature.values) {
      if (value.name == MeasureTerms.Area) {
        area = (value as FloatValue).value ?? 0;
      }
    }
    double height = 0;
    if (lineFeature.value != null) {
      height = (lineFeature.value as FloatValue).value ?? 0;
    }
    var volume = _caleVolume(area, height);
    final output = ref.meta.outputs.first;
    feature.updateFloatValue(
      output,
      roundDouble(volume, output.fractionalDigits),
      VidUsUnit.cm3,
    );
  }

  static double _caleVolume(double area, double d2) {
    return 2.0 / 3.0 * area * d2;
  }
}