onufitness_mobile/lib/screens/home/controllers/home_controller.dart

import 'dart:convert';
import 'package:get/get.dart';
import 'package:onufitness/constants/api_endpoints.dart';
import 'package:onufitness/services/logger_service.dart';
import 'package:intl/intl.dart';
import 'package:onufitness/screens/echoboard/models/post_model.dart';
import 'package:onufitness/screens/home/models/user_connection_report_respose_model.dart';
import 'package:onufitness/screens/home/models/goal_challenge_pie_chart_response_model.dart';
import 'package:onufitness/services/api_services/base_api_services.dart';

class FitnessController extends GetxController {
  //  RxBool isChatLoadingFromNotificationTap = false.obs;
  final logger = LoggerService();

  // Loading states
  RxBool isChallengeLoading = false.obs;
  RxBool isGoalLoading = false.obs;
  RxBool isConnectionLoading = false.obs;
  RxBool isConnectionReportLoading = false.obs;
  RxBool isGoalPieChartLoading = false.obs;
  RxBool isChallengePieChartLoading = false.obs;
  RxBool isTopPostLoading = false.obs;

  // Count values
  RxInt challengeCompleteCount = 0.obs;
  RxInt goalCompleteCount = 0.obs;
  RxInt userConnectionCount = 0.obs;

  // Connection Report Data
  Rx<UserConnectionReportResponseModel> connectionReport =
      UserConnectionReportResponseModel().obs;

  // Pie Chart Data
  Rx<GoalChallengePieChartResponseModel> goalPieChartData =
      GoalChallengePieChartResponseModel().obs;
  Rx<GoalChallengePieChartResponseModel> challengePieChartData =
      GoalChallengePieChartResponseModel().obs;

  // Top Post Data
  Rx<PostModel> topPostData = PostModel().obs;

  // Date range for connection report
  Rx<DateTime> startDate = DateTime.now().subtract(Duration(days: 7)).obs;
  Rx<DateTime> endDate = DateTime.now().obs;

  // Date range for pie charts
  Rx<DateTime> challengePieChartStartDate =
      DateTime.now().subtract(Duration(days: 365)).obs;
  Rx<DateTime> challengePieChartEndDate = DateTime.now().obs;

  Rx<DateTime> goalPieChartStartDate =
      DateTime.now().subtract(Duration(days: 365)).obs;
  Rx<DateTime> goalPieChartEndDate = DateTime.now().obs;

  // Date range for top post
  Rx<DateTime> topPostStartDate =
      DateTime.now().subtract(Duration(days: 7)).obs;
  Rx<DateTime> topPostEndDate = DateTime.now().obs;

  @override
  void onInit() {
    super.onInit();
    fetchDashboardData();
    getUserConnectionReport();
    getGoalPieChartData();
    getChallengePieChartData();
    getTopMostPost();
  }

  // Fetch all dashboard data
  Future<void> fetchDashboardData() async {
    await Future.wait([
      getChallengeCompleteCount(),
      getGoalCompleteCount(),
      getUserConnectionCount(),
    ]);
  }

  // Get Challenge Complete Count
  Future<bool> getChallengeCompleteCount() async {
    isChallengeLoading(true);
    var ret = false;
    try {
      var response = await ApiBase.getRequest(
        extendedURL: ApiUrl.getChallengeCompleteCount,
      );

      if (response.statusCode == 200 || response.statusCode == 201) {
        var jsonData = json.decode(response.body);
        if (jsonData['isSuccess'] == true && jsonData['data'] != null) {
          challengeCompleteCount.value = jsonData['data']['countValue'] ?? 0;
          ret = true;
        } else {
          ret = false;
        }
      } else {
        ret = false;
      }
    } catch (e, stackTrace) {
      ret = false;
      logger.error(
        "Exception in getChallengeCompleteCount",
        error: e,
        stackTrace: stackTrace,
      );
    }
    isChallengeLoading(false);
    return ret;
  }

  // Get Goal Complete Count
  Future<bool> getGoalCompleteCount() async {
    isGoalLoading(true);
    var ret = false;
    try {
      var response = await ApiBase.getRequest(
        extendedURL: ApiUrl.getGoalCompleteCount,
      );

      if (response.statusCode == 200 || response.statusCode == 201) {
        var jsonData = json.decode(response.body);
        if (jsonData['isSuccess'] == true && jsonData['data'] != null) {
          goalCompleteCount.value = jsonData['data']['countValue'] ?? 0;
          ret = true;
        } else {
          ret = false;
        }
      } else {
        ret = false;
      }
    } catch (e, stackTrace) {
      ret = false;
      logger.error(
        "Exception in getGoalCompleteCount",
        error: e,
        stackTrace: stackTrace,
      );
    }
    isGoalLoading(false);
    return ret;
  }

  // Get User Connection Count.........................................................................................
  Future<bool> getUserConnectionCount() async {
    isConnectionLoading(true);
    var ret = false;
    try {
      var response = await ApiBase.getRequest(
        extendedURL: ApiUrl.getUserConnectionCount,
      );

      if (response.statusCode == 200 || response.statusCode == 201) {
        var jsonData = json.decode(response.body);
        if (jsonData['isSuccess'] == true && jsonData['data'] != null) {
          userConnectionCount.value = jsonData['data']['countValue'] ?? 0;
          ret = true;
        } else {
          ret = false;
        }
      } else {
        ret = false;
      }
    } catch (e, stackTrace) {
      ret = false;
      logger.error(
        "Exception in getUserConnectionCount",
        error: e,
        stackTrace: stackTrace,
      );
    }
    isConnectionLoading(false);
    return ret;
  }

  // Connection Line Chart.........................................................................................
  Future<bool> getUserConnectionReport() async {
    isConnectionReportLoading(true);
    var ret = false;

    try {
      // Adjust to keep the same local date when converting to UTC
      DateTime localStart = startDate.value;
      DateTime localEnd = endDate.value;

      // Convert to UTC without shifting the date
      String formattedStartDate = DateFormat(
        "yyyy-MM-dd'T'00:00:00.000'Z'",
      ).format(DateTime.utc(localStart.year, localStart.month, localStart.day));

      String formattedEndDate = DateFormat(
        "yyyy-MM-dd'T'23:59:59.999'Z'",
      ).format(DateTime.utc(localEnd.year, localEnd.month, localEnd.day));

      var response = await ApiBase.getRequest(
        extendedURL:
            "${ApiUrl.getUserConnectionReport}?toDate=$formattedEndDate&fromDate=$formattedStartDate&checkType=Weekly",
      );

      if (response.statusCode == 200 || response.statusCode == 201) {
        connectionReport.value = userConnectionReportResponseModelFromJson(
          response.body,
        );
        ret = true;
      } else {
        ret = false;
      }
    } catch (e, stackTrace) {
      ret = false;
      logger.error(
        "Exception in getUserConnectionReport",
        error: e,
        stackTrace: stackTrace,
      );
    }

    isConnectionReportLoading(false);
    return ret;
  }

  // Get Goal Pie Chart Data...............................................................................
  Future<bool> getGoalPieChartData() async {
    isGoalPieChartLoading(true);
    var ret = false;
    try {
      String formattedStartDate = DateFormat(
        "yyyy-MM-dd'T'00:00:00.000'Z'",
      ).format(goalPieChartStartDate.value.toUtc());
      String formattedEndDate = DateFormat(
        "yyyy-MM-dd'T'00:00:00.000'Z'",
      ).format(goalPieChartEndDate.value.toUtc());

      var response = await ApiBase.getRequest(
        extendedURL:
            "${ApiUrl.getGoalPieChartData}?fromDate=$formattedStartDate&toDate=$formattedEndDate",
      );
      if (response.statusCode == 200 || response.statusCode == 201) {
        goalPieChartData.value = goalChallengePieChartResponseModelFromJson(
          response.body,
        );
        ret = true;
      } else {
        ret = false;
      }
    } catch (e, stackTrace) {
      ret = false;
      logger.error(
        "Exception in getGoalPieChartData",
        error: e,
        stackTrace: stackTrace,
      );
    }
    isGoalPieChartLoading(false);
    return ret;
  }

  // Get Challenge Pie Chart Data..............................................................................
  Future<bool> getChallengePieChartData() async {
    isChallengePieChartLoading(true);
    var ret = false;
    try {
      String formattedStartDate = DateFormat(
        "yyyy-MM-dd'T'00:00:00.000'Z'",
      ).format(challengePieChartStartDate.value.toUtc());
      String formattedEndDate = DateFormat(
        "yyyy-MM-dd'T'00:00:00.000'Z'",
      ).format(challengePieChartEndDate.value.toUtc());

      var response = await ApiBase.getRequest(
        extendedURL:
            "${ApiUrl.getChallengePieChartData}?fromDate=$formattedStartDate&toDate=$formattedEndDate",
      );
      if (response.statusCode == 200 || response.statusCode == 201) {
        challengePieChartData
            .value = goalChallengePieChartResponseModelFromJson(response.body);
        ret = true;
      } else {
        ret = false;
      }
    } catch (e, stackTrace) {
      ret = false;
      logger.error(
        "Exception in getChallengePieChartData",
        error: e,
        stackTrace: stackTrace,
      );
    }
    isChallengePieChartLoading(false);
    return ret;
  }

  // Get Top Most Post......................................................................................
  Future<bool> getTopMostPost() async {
    isTopPostLoading(true);
    var ret = false;
    try {
      String formattedStartDate = DateFormat(
        "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",
      ).format(topPostStartDate.value.toUtc());
      String formattedEndDate = DateFormat(
        "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",
      ).format(topPostEndDate.value.toUtc());

      var response = await ApiBase.getRequest(
        extendedURL:
            "${ApiUrl.getRecentTopMostPost}?toDate=$formattedEndDate&fromDate=$formattedStartDate&checkType=Weekly",
      );

      if (response.statusCode == 200 || response.statusCode == 201) {
        topPostData.value = postModelFromJson(response.body);
        ret = true;
      } else {
        ret = false;
      }
    } catch (e, stackTrace) {
      ret = false;
      logger.error(
        "Exception in getTopMostPost",
        error: e,
        stackTrace: stackTrace,
      );
    }
    isTopPostLoading(false);
    return ret;
  }

  // Update date range and fetch new data
  void updateDateRange(DateTime start, DateTime end) {
    startDate.value = start;
    endDate.value = end;
    getUserConnectionReport();
  }

  // Update pie chart date range and fetch new data
  void updatePieChartDateRangeForChallenge(DateTime start, DateTime end) {
    challengePieChartStartDate.value = start;
    challengePieChartEndDate.value = end;
    getChallengePieChartData();
  }

  // Update pie chart date range and fetch new data
  void updatePieChartDateRangeForGoal(DateTime start, DateTime end) {
    goalPieChartStartDate.value = start;
    goalPieChartEndDate.value = end;
    getGoalPieChartData();
  }

  // Update top post date range and fetch new data
  void updateTopPostDateRange(DateTime start, DateTime end) {
    topPostStartDate.value = start;
    topPostEndDate.value = end;
    getTopMostPost();
  }

  // Refresh dashboard data
  Future<void> refreshDashboard() async {
    await fetchDashboardData();
    await getUserConnectionReport();
    await getGoalPieChartData();
    await getChallengePieChartData();
    await getTopMostPost();
  }
}