fis_lib_measure/lib/process/calcuators/simpson.dart

// ignore_for_file: non_constant_identifier_names

import 'package:fis_measure/configs/patient.dart';
import 'package:fis_measure/interfaces/process/calculators/values.dart';
import 'package:fis_measure/interfaces/process/items/item_metas.dart';
import 'package:fis_measure/interfaces/process/items/terms.dart';
import 'package:fis_measure/process/calcuators/unit_formulas/base/utils.dart';
import 'package:fis_measure/process/calcuators/unit_formulas/index.dart';
import 'package:fis_measure/process/items/item_feature.dart';
import 'package:fis_measure/process/items/top_item.dart';
import 'package:fis_measure/process/primitives/combos/simpson.dart';
import 'package:fis_measure/process/primitives/multi_method/multi_simpson_path.dart';
import 'package:fis_measure/process/primitives/simpson_path.dart';
import 'package:vid/us/vid_us_unit.dart';

import 'calculator.dart';
import 'formulas/cardiac.dart';
import 'lv_study.dart';
import 'dart:math' as math;

class LvSimpsonCal extends LvStudyCalculatorBase<LvStudySimpson> {
  LvSimpsonCal(super.ref) {
    //
  }

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

    final feature = ref.feature!;

    restoreVals();

    feature.updateStringValue(
      ItemOutputMeta(
          ref.meta.description, ref.meta.description, VidUsUnit.None),
      "",
    );

    for (var childItem in ref.childItems) {
      _clacChildItem(childItem as MultiSimpsonPath);
    }

    for (var output in ref.meta.outputs) {
      switch (output.name) {
        case MeasureTerms.LVEDV:
          updateLVEDV();
          break;
        case MeasureTerms.LVESV:
          updateLVESV();
          break;
        case MeasureTerms.SV:
          updateSV();
          break;
        case MeasureTerms.EF:
          updateEF();
          break;
        case MeasureTerms.FS:
          updatePercentFS();
          break;
        case MeasureTerms.SI:
          updateSI();
          break;
        case MeasureTerms.LVEDVI:
          updateLVEDVI();
          break;
        case MeasureTerms.LVESVI:
          updateLVESVI();
          break;
      }
    }

    // _updateA2cGroup();
    // _updateA4cGroup();
  }

  @override
  void updateLVEDV() {
    final value = _clacLvedvNew(ref.a2cLvedv, ref.a4cLvedv);
    if (value != null) {
      updateFloatValueByName(MeasureTerms.LVEDV, value, unit: VidUsUnit.cm3);
      v.lvedv = value;
    }
  }

  @override
  void updateLVESV() {
    final value = _clacLvedvNew(ref.a2cLvesv, ref.a4cLvesv);
    if (value != null) {
      updateFloatValueByName(MeasureTerms.LVESV, value, unit: VidUsUnit.cm3);
      v.lvesv = value;
    }
  }

  double? _clacLvedv(MultiSimpsonPath path1, MultiSimpsonPath path2) {
    final feature1 = findChildFeature(path1);
    final feature2 = findChildFeature(path2);
    if (feature1 == null || feature2 == null) {
      return null;
    }
    feature1 as SimpsonPathFeature;
    feature2 as SimpsonPathFeature;
    final distance1 = feature1.centerLineLength;
    final distance2 = feature2.centerLineLength;

    int index = 0;

    List<double> aDiameters =
        List.generate(SimpsonPath.splitterCount, (index) => 0);
    index = 0;
    feature1.horizontalSplitterLegths.forEach((key, value) {
      aDiameters[index++] = value;
    });

    List<double> bDiameters =
        List.generate(SimpsonPath.splitterCount, (index) => 0);
    index = 0;
    feature2.horizontalSplitterLegths.forEach((key, value) {
      bDiameters[index++] = value;
    });

    final longDiameter = (distance1 + distance2) / 2.0;
    final lvesv = CardiacFormulas.lvSimsonVolume(
      longDiameter,
      aDiameters,
      bDiameters,
      SimpsonPath.splitterCount,
    );
    return lvesv;
  }

  double? _clacLvedvNew(MultiSimpsonPath path1, MultiSimpsonPath path2) {
    final feature1 = findChildFeature(path1);
    final feature2 = findChildFeature(path2);
    if (feature1 == null || feature2 == null) {
      return null;
    }
    feature1 as SimpsonPathFeature;
    feature2 as SimpsonPathFeature;
    final distance1 = feature1.centerLineLength;
    final distance2 = feature2.centerLineLength;

    int index = 0;

    List<double> aDiameters =
        List.generate(SimpsonPath.splitterCount, (index) => 0);
    index = 0;
    feature1.horizontalSplitterLegths.forEach((key, value) {
      aDiameters[index++] = value;
    });

    List<double> bDiameters =
        List.generate(SimpsonPath.splitterCount, (index) => 0);
    index = 0;
    feature2.horizontalSplitterLegths.forEach((key, value) {
      bDiameters[index++] = value;
    });

    double sum = 0;
    for (var i = 0; i < SimpsonPath.splitterCount; i++) {
      sum += aDiameters[i] * bDiameters[i];
    }
    final maxL = math.max(distance1, distance2);
    final value = maxL * 3.1415926 / (4 * 20) * sum;
    return value;
  }

  void _clacChildItem(MultiSimpsonPath childItem) {
    final feature = findChildFeature(childItem);
    if (feature == null) {
      return;
    }
    feature as SimpsonPathFeature;

    // final outputs = childItem.meta.outputs;
    // TODO:
    final itemName = childItem.meta.description.split(' ').first;
    final outputs = [
      ItemOutputMeta("Area", "$itemName LVAs", VidUsUnit.mm2),
      ItemOutputMeta("L", "$itemName LVLs", VidUsUnit.mm),
    ];
    for (var output in outputs) {
      switch (output.name) {
        case "Area":
          feature.updateFloatValue(output, feature.area, VidUsUnit.cm2);
          break;
        case "L":
          feature.updateFloatValue(
              output, feature.centerLineLength, VidUsUnit.cm);
          break;
        default:
      }
    }
  }

  void _updateA2cGroup() {
    _updateLVEDV_A2C();
    _updateLVESV_A2C();
  }

  void _updateA4cGroup() {
    _updateLVEDV_A2C();
    _updateLVESV_A2C();
  }

  void _updateLVEDV_A2C() {
    final feature = findChildFeature(ref.a2cLvedv);
    if (feature == null) {
      return;
    }
    feature as SimpsonPathFeature;
    final value = _SimpsonFormulas.lvedv(
      feature.area,
      feature.centerLineLength,
    );
    ref.feature!.updateFloatValue(
      ItemOutputMeta("LVEDV(A2C Simp)", "LVEDV(A2C Simp)", VidUsUnit.ml),
      value,
      VidUsUnit.ml,
    );
  }

  void _updateLVESV_A2C() {
    final feature = findChildFeature(ref.a2cLvesv);
    if (feature == null) {
      return;
    }
    feature as SimpsonPathFeature;
    final value = _SimpsonFormulas.lvedv(
      feature.area,
      feature.centerLineLength,
    );
    ref.feature!.updateFloatValue(
      ItemOutputMeta("LVESV(A2C Simp)", "LVESV(A2C Simp)", VidUsUnit.ml),
      value,
      VidUsUnit.ml,
    );
  }

  void _updateLVEDV_A4C() {}
  void _updateLVESV_A4C() {}
}

class LvSingleSimpsonCal extends LvStudyCalculatorBase<LvStudySingleSimpson> {
  LvSingleSimpsonCal(super.ref) {
    //
  }

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

    final feature = ref.feature!;

    restoreVals();

    feature.updateStringValue(
      ItemOutputMeta(
          ref.meta.description, ref.meta.description, VidUsUnit.None),
      "",
    );

    _clacChildItem(ref.lvedv);

    for (var output in ref.meta.outputs) {
      switch (output.name) {
        case MeasureTerms.LVEDV:
          updateLVEDV();
          break;
        case MeasureTerms.LVESV:
          updateLVESV();
          break;
        case MeasureTerms.SV:
          updateSV();
          break;
        case MeasureTerms.EF:
          updateEF();
          break;
        case MeasureTerms.SI:
          updateSI();
          break;
        case MeasureTerms.LVEDVI:
          updateLVEDVI();
          break;
        case MeasureTerms.LVESVI:
          updateLVESVI();
          break;
      }
    }

    /**
     * 
     <OutPut Id="LVEDV" IsEnabled="False" CalculationIDs="LVEDV(BP Simp)"/>
<OutPut Id="LVESV" IsEnabled="False" CalculationIDs="LVESV(BP Simp)"/>
<OutPut Id="SV" IsEnabled="False" CalculationIDs="SV(Mod Simp)"/>
<OutPut Id="EF" IsEnabled="False" CalculationIDs="EF(Mod Simp)"/>
<OutPut Id="SI" IsEnabled="False" CalculationIDs="SI(Mod Simp)"/>
<OutPut Id="LVEDVI" IsEnabled="False" CalculationIDs="LVEDVI(Mod Simp)"/>
<OutPut Id="LVESVI" IsEnabled="False" CalculationIDs="LVESVI(Mod Simp)"/>
<OutPut Id="CO" IsEnabled="False" CalculationIDs="CO(Mod Simp)"/>
<OutPut Id="CI" IsEnabled="False" CalculationIDs="CI(Mod Simp)"/>
     */
  }

  @override
  void updateLVEDV() {
    final value = _calcLvedvNew(ref.lvedv);
    if (value != null) {
      updateFloatValueByName(MeasureTerms.LVEDV, value, unit: VidUsUnit.cm3);
      v.lvedv = value;
    }
  }

  @override
  void updateLVESV() {
    final value = _calcLvedvNew(ref.lvesv);
    if (value != null) {
      updateFloatValueByName(MeasureTerms.LVESV, value, unit: VidUsUnit.cm3);
      v.lvesv = value;
    }
  }

  double? _calcLvedv(MultiSimpsonPath item) {
    if (item.feature == null) {
      return null;
    }

    final feature = item.feature!;

    double longDiameter = roundDouble(feature.centerLineLength);
    int index = 0;
    List<double> bDiameters =
        List.generate(SimpsonPath.splitterCount, (index) => 0);
    feature.horizontalSplitterLegths.forEach((key, value) {
      bDiameters[index++] = value;
    });

    return CardiacFormulas.lvSimsonVolume(
      longDiameter,
      bDiameters,
      bDiameters,
      SimpsonPath.splitterCount,
    );
  }

  double? _calcLvedvNew(MultiSimpsonPath item) {
    final feature = findChildFeature(item);
    if (feature == null) {
      return null;
    }

    feature as SimpsonPathFeature;

    double longDiameter = roundDouble(feature.centerLineLength);
    int index = 0;
    List<double> bDiameters =
        List.generate(SimpsonPath.splitterCount, (index) => 0);
    feature.horizontalSplitterLegths.forEach((key, value) {
      bDiameters[index++] = value;
    });

    double sum = 0;
    for (var i = 0; i < SimpsonPath.splitterCount; i++) {
      sum += math.pow(bDiameters[i], 2).toDouble();
    }
    var value = longDiameter * 3.1415926 / (4 * 20) * sum;
    return value;

    return CardiacFormulas.lvSimsonVolume(
      longDiameter,
      bDiameters,
      bDiameters,
      SimpsonPath.splitterCount,
    );
  }

  void _clacChildItem(MultiSimpsonPath childItem) {
    final feature = findChildFeature(childItem);
    if (feature == null) {
      return;
    }
    feature as SimpsonPathFeature;

    // final outputs = childItem.meta.outputs;
    // TODO:
    final itemName = childItem.meta.description.split(' ').first;
    final outputs = [
      ItemOutputMeta("Area", "$itemName LVAs", VidUsUnit.mm2),
      ItemOutputMeta("L", "$itemName LVLs", VidUsUnit.mm),
    ];
    for (var output in outputs) {
      switch (output.name) {
        case "Area":
          feature.updateFloatValue(output, feature.area, VidUsUnit.cm2);
          break;
        case "L":
          feature.updateFloatValue(
              output, feature.centerLineLength, VidUsUnit.cm);
          break;
        default:
      }
    }
  }
}

abstract class _SimpsonFormulas {
  static double lvedv(double area, double distance) {
    final value = 0.85 * math.pow(area, 2) / distance;
    return value;
  }
}

class LvSimpsonCalNew extends LvSimpsonCalBase<LvStudySimpson> {
  LvSimpsonCalNew(super.ref) {
    //
  }

  @override
  void calculate() {
    super.calculate();

    if (ref.feature == null) return;

    final feature = ref.feature!;

    feature.updateStringValue(
      ItemOutputMeta(
          ref.meta.description, ref.meta.description, VidUsUnit.None),
      "",
    );

    for (var childItem in ref.childItems) {
      clacChildItem(childItem as MultiSimpsonPath);
    }

    calcCouple();
    calcA2c(ref.a2cLvedv, ref.a2cLvesv);
    calcA2c(ref.a4cLvedv, ref.a4cLvesv);

    doOutput();
  }

  void calcCouple() {
    final featureA2cD = findChildFeature(ref.a2cLvedv);
    final featureA2cS = findChildFeature(ref.a2cLvesv);
    final featureA4cD = findChildFeature(ref.a4cLvedv);
    final featureA4cS = findChildFeature(ref.a4cLvesv);

    UnitFloatValue? edv;
    UnitFloatValue? esv;

    if (featureA2cD != null && featureA4cD != null) {
      edv = coupleLVEDV(
        featureA4cD as SimpsonPathFeature,
        featureA2cD as SimpsonPathFeature,
      );
    }
    if (featureA2cS != null && featureA4cS != null) {
      esv = coupleLVEDV(
        featureA4cS as SimpsonPathFeature,
        featureA2cS as SimpsonPathFeature,
      );
    }
    v.coupleEDV = edv;
    v.coupleESV = esv;
    if (edv != null && esv != null) {
      v.coupleSV = calcSv(edv, esv);
      v.coupleEF = calcEf(edv, esv);
      v.coupleCO = calcCo(edv, esv);
    }
  }
}

class LvSingleSimpsonCalNew extends LvSimpsonCalBase<LvStudySingleSimpson> {
  LvSingleSimpsonCalNew(super.ref) {
    //
  }

  @override
  void calculate() {
    super.calculate();

    if (ref.feature == null) return;

    final feature = ref.feature!;

    feature.updateStringValue(
      ItemOutputMeta(
          ref.meta.description, ref.meta.description, VidUsUnit.None),
      "",
    );

    for (var childItem in ref.childItems) {
      clacChildItem(childItem as MultiSimpsonPath);
    }

    if (ref.meta.description.toLowerCase().contains("a2c")) {
      calcA2c(ref.lvedv, ref.lvesv);
    }

    if (ref.meta.description.toLowerCase().contains("a4c")) {
      calcA4c(ref.lvedv, ref.lvesv);
    }

    doOutput();
  }
}

abstract class LvSimpsonCalBase<T extends TopMeasureItem>
    extends Calculator<T, double> {
  LvSimpsonCalBase(super.ref);

  _SimpsonValues v = _SimpsonValues();

  @override
  void calculate() {
    v = _SimpsonValues();
  }

  void doOutput() {
    final feature = ref.feature!;

    for (var output in ref.meta.outputs) {
      switch (output.name) {
        // Couple
        case MeasureTerms.LVEDV:
          _outputVal(feature, output, v.coupleEDV);
          break;
        case MeasureTerms.LVESV:
          _outputVal(feature, output, v.coupleESV);
          break;
        case MeasureTerms.SV:
          _outputVal(feature, output, v.coupleSV);
          break;
        case MeasureTerms.EF:
          _outputVal(feature, output, v.coupleEF);
          break;
        case MeasureTerms.CO:
          _outputVal(feature, output, v.coupleCO);
          break;
        // A2C
        case "A2C LVEDV":
          _outputVal(feature, output, v.a2cEDV);
          break;
        case "A2C LVESV":
          _outputVal(feature, output, v.a2cESV);
          break;
        case "A2C SV":
          _outputVal(feature, output, v.a2cSV);
          break;
        case "A2C EF":
          _outputVal(feature, output, v.a2cEF);
          break;
        case "A2C CO":
          _outputVal(feature, output, v.a2cCO);
          break;
        // A4C
        case "A4C LVEDV":
          _outputVal(feature, output, v.a4cEDV);
          break;
        case "A4C LVESV":
          _outputVal(feature, output, v.a4cESV);
          break;
        case "A4C SV":
          _outputVal(feature, output, v.a4cSV);
          break;
        case "A4C EF":
          _outputVal(feature, output, v.a4cEF);
          break;
        case "A4C CO":
          _outputVal(feature, output, v.a4cCO);
          break;
        default:
      }
    }
  }

  void _outputVal(
    MeasureItemFeature feature,
    ItemOutputMeta output,
    UnitFloatValue? val,
  ) {
    if (val != null) {
      feature.updateFloatValue(output, val.value, val.unit);
    }
  }

  void calcA2c(MultiSimpsonPath itemD, MultiSimpsonPath itemS) {
    final featureD = findChildFeature(itemD);
    final featureS = findChildFeature(itemS);
    UnitFloatValue? edv;
    UnitFloatValue? esv;
    if (featureD != null) {
      edv = singleLVEDV(featureD as SimpsonPathFeature);
    }
    if (featureS != null) {
      esv = singleLVEDV(featureS as SimpsonPathFeature);
    }
    v.a2cEDV = edv;
    v.a2cESV = esv;
    if (edv != null && esv != null) {
      v.a2cSV = calcSv(edv, esv);
      v.a2cEF = calcEf(edv, esv);
      v.a2cCO = calcCo(edv, esv);
    }
  }

  void calcA4c(MultiSimpsonPath itemD, MultiSimpsonPath itemS) {
    final featureD = findChildFeature(itemD);
    final featureS = findChildFeature(itemS);
    UnitFloatValue? edv;
    UnitFloatValue? esv;
    if (featureD != null) {
      edv = singleLVEDV(featureD as SimpsonPathFeature);
    }
    if (featureS != null) {
      esv = singleLVEDV(featureS as SimpsonPathFeature);
    }
    v.a4cEDV = edv;
    v.a4cESV = esv;
    if (edv != null && esv != null) {
      v.a4cSV = calcSv(edv, esv);
      v.a4cEF = calcEf(edv, esv);
      v.a4cCO = calcCo(edv, esv);
    }
  }

  UnitFloatValue? coupleLVEDV(
    SimpsonPathFeature featureA,
    SimpsonPathFeature featureB,
  ) {
    // max([A4C LVEDV Simpson|L"cm;2D"],[A2C LVEDV Simpson|L"cm;2D"]) *3.1415926/(4*20) * Sum(2D1*4D1 + 2D2*4D2 + ... + 2D20*4D20)
    double lA = roundDouble(featureA.centerLineLength);
    double lB = roundDouble(featureB.centerLineLength);
    double lMax = math.max(lA, lB);

    final splitterALengths = featureA.horizontalSplitterLegths.values.toList();
    final splitterBLengths = featureB.horizontalSplitterLegths.values.toList();

    if (splitterALengths.length < SimpsonPath.splitterCount ||
        splitterBLengths.length < SimpsonPath.splitterCount) {
      return null;
    }

    double sum = 0;
    for (var i = 0; i < SimpsonPath.splitterCount; i++) {
      final dA = roundDouble(splitterALengths[i]);
      final dB = roundDouble(splitterBLengths[i]);
      sum += dA * dB;
    }

    var value = lMax * 3.1415926 / (4 * 20) * sum;
    value = value * 4;
    return UnitFloatValue(value, VidUsUnit.ml);
  }

  UnitFloatValue? singleLVEDV(SimpsonPathFeature feature) {
    // [A2C LVEDV Simpson|L"cm;2D"]*3.1415926/(4*20)* Sum(pow(D1,2),pow(D2,2),...,pow(D20,2))
    double l = roundDouble(feature.centerLineLength);

    final splitterLengths = feature.horizontalSplitterLegths.values.toList();

    if (splitterLengths.length < SimpsonPath.splitterCount) {
      return null;
    }

    double sum = 0;
    for (var i = 0; i < SimpsonPath.splitterCount; i++) {
      final d = math.pow(splitterLengths[i], 2).toDouble();
      sum += roundDouble(d);
    }
    var value = l * 3.1415926 / (4 * 20) * sum;
    return UnitFloatValue(value, VidUsUnit.ml);
  }

  UnitFloatValue calcSv(UnitFloatValue lvedv, UnitFloatValue lvesv) {
    // [LVEDV(A2C Simp)"ml;"]-[LVESV(A2C Simp)"ml;"]
    final value = lvedv.convert(VidUsUnit.ml) - lvesv.convert(VidUsUnit.ml);
    return UnitFloatValue(value, VidUsUnit.ml);
  }

  UnitFloatValue calcEf(UnitFloatValue lvedv, UnitFloatValue lvesv) {
    // ([LVEDV(A2C Simp)"ml;"]-[LVESV(A2C Simp)"ml;"])/[LVEDV(A2C Simp)"ml;"]*100
    final value = UnitFormulas.cardiac.ef(lvedv, lvesv);
    return value;
  }

  UnitFloatValue? calcCo(UnitFloatValue lvedv, UnitFloatValue lvesv) {
    // ([LVEDV(A2C Simp)"ml;"]-[LVESV(A2C Simp)"ml;"])*{[HR|HR"HR;M"]}/1000
    // ([LVEDV(A2C Simp)"ml;"]-[LVESV(A2C Simp)"ml;"])*{[HR|HR"HR;M"],[HR"HR;PatientInfo"]}/1000
    final hr = GlobalPatientConfig.hr;
    if (hr == null) {
      return null;
    }
    final edv = lvedv.convert(VidUsUnit.ml);
    final esv = lvesv.convert(VidUsUnit.ml);
    final value = (edv - esv) * hr / 1000;
    return UnitFloatValue(value, VidUsUnit.Lmin);
  }

  void clacChildItem(MultiSimpsonPath childItem) {
    final feature = findChildFeature(childItem);
    if (feature == null) {
      return;
    }
    feature as SimpsonPathFeature;

    // final outputs = childItem.meta.outputs;
    // TODO:
    final itemName = childItem.meta.name.split(' ').first;
    final isD = itemName.toLowerCase().contains("edv");
    final sideTag = isD ? "d" : "s";
    final outputs = [
      ItemOutputMeta("Area", "$itemName LVA$sideTag", VidUsUnit.mm2),
      ItemOutputMeta("L", "$itemName LVL$sideTag", VidUsUnit.mm),
    ];
    for (var output in outputs) {
      switch (output.name) {
        case "Area":
          feature.updateFloatValue(output, feature.area, VidUsUnit.cm2);
          break;
        case "L":
          feature.updateFloatValue(
              output, feature.centerLineLength, VidUsUnit.cm);
          break;
        default:
      }
    }
  }
}

class _SimpsonValues {
  UnitFloatValue? a2cEDV;
  UnitFloatValue? a2cESV;
  UnitFloatValue? a2cSV;
  UnitFloatValue? a2cEF;
  UnitFloatValue? a2cCO;

  UnitFloatValue? a4cEDV;
  UnitFloatValue? a4cESV;
  UnitFloatValue? a4cSV;
  UnitFloatValue? a4cEF;
  UnitFloatValue? a4cCO;

  UnitFloatValue? coupleEDV;
  UnitFloatValue? coupleESV;
  UnitFloatValue? coupleSV;
  UnitFloatValue? coupleEF;
  UnitFloatValue? coupleCO;
}