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());
  // printMenstrualCycleLogs("loggedData ${loggedData.length}");

  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() ?? ''
  };*/

  // 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 ?? []
  };

  Map<String, UserLogReportData> logReportMap = {};

  for (var report in loggedData) {
    String dateKey = CalenderDateUtils.dateDayFormat(report.logDate!);

    logReportMap[dateKey] = report;

    //printMenstrualCycleLogs("report.symptomsData ${report.symptomsData!.length}");
    for (var symptom in report.symptomsData ?? []) {
      String symptomNameLower = symptom.symptomName?.toLowerCase() ?? '';
      // printMenstrualCycleLogs("symptomNameLower ${symptomNameLower}");
      if (!symptomsMap.containsKey(symptomNameLower)) {
        symptomsMap[symptomNameLower] = symptom;
      }
    }
  }

  if (symptomsMap.isEmpty) return symptomsPatternList;
  // printMenstrualCycleLogs("symptomsMap ${symptomsMap.length}");

  // get symptoms data based on cycle
  List<PeriodsDateRange> periodRange = await getAllPeriodsDetails();

  for (var symptoms in symptomsMap.values) {
    //printMenstrualCycleLogs("symptoms ${symptoms.symptomName}");
    SymptomsPattern symptomsPattern = SymptomsPattern(cycleData: []);
    int symptomsCount = 0;
    symptomsPattern.symptomsName = symptoms.symptomName;
    int cycleCount = 1;
    for (var periodRangeItem in periodRange) {
      // generate cycle data
      if (cycleCount >= numberOfCycle) break;

      CycleData cycleData = CycleData(cycleDates: []);
      // generate symptoms data
      List<CycleDates> cycleDatesList = [];
      /*  printMenstrualCycleLogs(
          'periodRangeItem.cycleLength ${periodRangeItem.cycleStartDate}');

      printMenstrualCycleLogs(
          'periodRangeItem.cycleLength ${periodRangeItem.cycleLength}');*/

      for (int i = 0; i < (periodRangeItem.cycleLength ?? 0); i++) {
        CycleDates cycleDates = CycleDates();

        DateTime cycleDateObj =
            DateTime.parse(periodRangeItem.cycleStartDate!)
                .add(Duration(days: i));
        String cycleDateStr = CalenderDateUtils.dateDayFormat(cycleDateObj);
        // printMenstrualCycleLogs('cycleDateStr ${cycleDateStr}');
        int? loggedCycleDay = logReportMap[cycleDateStr]?.cycleDay;

        cycleDates.cycleDay = "${loggedCycleDay ?? (i + 1)}";
        cycleDates.cycleDate = cycleDateStr;
        cycleDates.isFoundSymptoms = false;

        bool isFound = logDataMap[cycleDateStr]?.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;
}