problem_check_system/lib/data/repositories/problem_repository.dart

import 'package:dio/dio.dart';
import 'package:get/get.dart' hide MultipartFile, FormData, Response;
import 'package:problem_check_system/core/extensions/http_response_extension.dart';
import 'package:problem_check_system/core/utils/constants/api_endpoints.dart';
import 'package:problem_check_system/data/models/problem_model.dart';
import 'package:problem_check_system/data/models/server_problem.dart';
import 'package:problem_check_system/data/providers/connectivity_provider.dart';
import 'package:problem_check_system/data/providers/http_provider.dart';
import 'package:problem_check_system/data/providers/sqlite_provider.dart';

/// 问题仓库，负责处理问题数据的本地持久化。
/// 它封装了底层数据库操作，为业务逻辑层提供一个简洁的接口。
class ProblemRepository extends GetxService {
  final SQLiteProvider sqliteProvider;
  final HttpProvider httpProvider;
  final ConnectivityProvider connectivityProvider;

  RxBool get isOnline => connectivityProvider.isOnline;

  ProblemRepository({
    required this.sqliteProvider,
    required this.httpProvider,
    required this.connectivityProvider,
  });

  /// 更新本地数据库中的一个问题。
  Future<void> updateProblem(Problem problem) async {
    await sqliteProvider.updateProblem(problem);
  }

  /// 通用查询方法，根据可选的筛选条件获取问题列表。
  /// - `startDate`/`endDate`：筛选创建时间范围。
  /// - `syncStatus`：筛选上传状态（'已上传', '未上传', '全部'）。
  /// - `bindStatus`：筛选绑定状态（'已绑定', '未绑定', '全部'）。
  Future getProblems({
    DateTime? startDate,
    DateTime? endDate,
    String? syncStatus,
    String? bindStatus,
  }) async {
    return await sqliteProvider.getProblems(
      startDate: startDate,
      endDate: endDate,
      syncStatus: syncStatus,
      bindStatus: bindStatus,
    );
  }

  Future<void> insertProblem(Problem problem) async {
    await sqliteProvider.insertProblem(problem);
  }

  Future<void> deleteProblem(String problemId) async {
    await sqliteProvider.deleteProblem(problemId);
  }

  // 在ProblemRepository中添加
  Future<List<ServerProblem>> fetchProblemsFromServer({
    DateTime? startTime,
    DateTime? endTime,
    int? pageNumber,
    int? pageSize,
    CancelToken? cancelToken,
  }) async {
    try {
      final response = await httpProvider.get(
        ApiEndpoints.getProblems,
        queryParameters: {
          if (startTime != null)
            'StartTime': startTime.toUtc().toIso8601String(),
          if (endTime != null) 'EndTime': endTime.toUtc().toIso8601String(),
          if (pageNumber != null) 'pageNumber': pageNumber,
          if (pageSize != null) 'pageSize': pageSize,
        },
        cancelToken: cancelToken,
      );

      if (response.isSuccess) {
        // Dio 会自动解析 JSON，response.data 已经是 Map 或 List
        final Map<String, dynamic> data = response.data;
        final List<dynamic> items = data['items'];

        // 使用 Freezed 生成的 fromJson 方法
        return items.map((item) => ServerProblem.fromJson(item)).toList();
      } else {
        throw Exception('拉取问题失败: ${response.statusCode}');
      }
    } on DioException catch (e) {
      Get.log("Dio 异常$e");
      rethrow;
    } catch (e) {
      Get.log("解析失败：$e");
      rethrow;
    }
  }

  /// post
  Future<Response> post(
    Map<String, Object> apiPayload,
    CancelToken cancelToken,
  ) async {
    // 3. 发送给服务器
    final response = await httpProvider.post(
      ApiEndpoints.postProblem,
      data: apiPayload,
      cancelToken: cancelToken,
    );
    return response;
  }

  /// put
  Future<Response> put(
    String id,
    Map<String, Object> apiPayload,
    CancelToken cancelToken,
  ) async {
    // 3. 发送给服务器
    final response = await httpProvider.put(
      ApiEndpoints.putProblemById(id),
      data: apiPayload,
      cancelToken: cancelToken,
    );
    return response;
  }

  /// delete
  Future<Response> delete(String id, CancelToken cancelToken) async {
    // 3. 发送给服务器
    final response = await httpProvider.delete(
      ApiEndpoints.deleteProblemById(id),
      cancelToken: cancelToken,
    );
    return response;
  }
}