getSymptomsPatternBasedOnCycle method

Future<List<SymptomsPattern>> getSymptomsPatternBasedOnCycle({ int numberOfCycle = 5, })

Implementation

Future<List<SymptomsPattern>> getSymptomsPatternBasedOnCycle(
    {int numberOfCycle = 5}) async {
  if (numberOfCycle < 1) {
    throw "Required valid number of cycle day";
  }

  List<SymptomsPattern> symptomsPatternList = [];
  // Fetch logged symptoms data
  List<UserLogReportData> loggedData = await getSymptomsLogReport(
      startDate: DateTime.now().add(const Duration(days: -10000)),
      endDate: DateTime.now());

  if (loggedData.isEmpty) return symptomsPatternList;

  int phaseId = await getPhaseId();
  List<SymptomsData> listSymptomsDataBasedOnPhase = defaultSymptomsData
      .expand((category) => category.symptomsData ?? <SymptomsData>[])
      .where(
          (symptomsData) => symptomsData.phaseIds?.contains(phaseId) ?? false)
      .toList();

  Map<String, SymptomsData> symptomsMap = {};
  Set<String> phaseSymptomsSet = {
    for (var phaseSymptom in listSymptomsDataBasedOnPhase)
      phaseSymptom.symptomName?.toLowerCase() ?? ''
  };

  for (var report in loggedData) {
    for (var symptom in report.symptomsData ?? []) {
      String symptomNameLower = symptom.symptomName?.toLowerCase() ?? '';
      if (phaseSymptomsSet.contains(symptomNameLower)) {
        symptomsMap[symptomNameLower] = symptom;
      }
    }
  }

  if (symptomsMap.isEmpty) return symptomsPatternList;

  // Create a map of log data for quick lookup
  Map<String, List<SymptomsData>> logDataMap = {
    for (var log in loggedData)
      CalenderDateUtils.dateDayFormat(log.logDate!): log.symptomsData ?? []
  };

  // get symptoms data based on cycle
  List<PeriodsDateRange> periodRange = await getAllPeriodsDetails();
  for (var symptoms in symptomsMap.values) {
    SymptomsPattern symptomsPattern = SymptomsPattern(cycleData: []);
    int symptomsCount = 0;
    symptomsPattern.symptomsName = symptoms.symptomName;
    int cycleCount = 1;
    x:
    for (var periodRangeItem in periodRange) {
      // generate cycle data
      if (cycleCount > numberOfCycle) {
        break x;
      }
      CycleData cycleData = CycleData(cycleDates: []);
      // generate symptoms data
      List<CycleDates> cycleDatesList = [];
      for (int i = 0; i < (periodRangeItem.cycleLength ?? 0); i++) {
        CycleDates cycleDates = CycleDates();
        cycleDates.cycleDate = CalenderDateUtils.dateDayFormat(
            DateTime.parse(periodRangeItem.cycleStartDate!)
                .add(Duration(days: i)));
        cycleDates.isFoundSymptoms = false;

        String cycleDate = CalenderDateUtils.dateDayFormat(
            DateTime.parse(periodRangeItem.cycleStartDate!)
                .add(Duration(days: i)));

        bool isFound = logDataMap[cycleDate]?.any((s) =>
                s.symptomName!.toLowerCase() ==
                symptoms.symptomName!.toLowerCase()) ??
            false;

        if (isFound) {
          symptomsCount = symptomsCount + 1;
          cycleDates.isFoundSymptoms = true;
        }

        cycleDatesList.add(cycleDates);
      }
      cycleData.cycleDates!.addAll(cycleDatesList);
      cycleData.cycleStartDate = periodRangeItem.cycleStartDate;
      cycleData.cycleEndDate = periodRangeItem.cycleEndDate;
      cycleData.isCurrentCycle = (periodRangeItem.cycleEndDate != null &&
              periodRangeItem.cycleEndDate!.isNotEmpty)
          ? false
          : true;
      symptomsPattern.cycleData!.add(cycleData);
      cycleCount = cycleCount + 1;
    }
    symptomsPattern.numberOfCount = symptomsCount;
    symptomsPatternList.add(symptomsPattern);
  }

  return symptomsPatternList;
}