1
import 'dart:async';
2
import 'package:cattodo_flutter/common/api/user_api.dart';
3
import 'package:cattodo_flutter/common/constants/global_constants.dart';
4
import 'package:cattodo_flutter/common/models/Result/result.dart';
5
import 'package:cattodo_flutter/common/services/user_service.dart';
6
import 'package:dio/dio.dart';
7
import 'package:flutter_smart_dialog/flutter_smart_dialog.dart';
8
import 'package:get/get.dart' as getx; // 避免冲突
9
import 'package:logger/logger.dart';
10

11
class HttpUtils {
12
  static final HttpUtils _instance = HttpUtils._internal();
13
  factory HttpUtils() => _instance;
14

15
  late Dio _dio;
16
  final Logger _logger = getx.Get.find<Logger>();
17

18
  // 刷新 Token 标志位和 Completer
19
  bool _isRefreshing = false;
20
  Completer<void>? _refreshCompleter;
21

22
  HttpUtils._internal() {
23
    _dio = Dio(
24
      BaseOptions(
25
        baseUrl: GlobalConstants.baseUrl,
26
        sendTimeout: const Duration(seconds: GlobalConstants.sendTimeout),
27
        connectTimeout: const Duration(seconds: GlobalConstants.connectTimeout),
28
        receiveTimeout: const Duration(seconds: GlobalConstants.receiveTimeout),
29
      ),
30
    );
31

32
    // 拦截器
33
    _dio.interceptors.add(
34
      InterceptorsWrapper(
35
        onRequest: (options, handler) {
36
          // 这里加 Token
37
          if (getx.Get.isRegistered<UserService>() && UserService.to.hasToken) {
38
            options.headers['Authorization'] =
39
                'Bearer ${UserService.to.token?.accessToken}';
40
          }
41
          return handler.next(options);
42
        },
43
        onResponse: (response, handler) async {
44
          // 可以在这里统一处理 {code: 200}
45
          final data = response.data;
46
          // 假设后端返回结构为：code, message, data
47
          if (data is Map<String, dynamic>) {
48
            final int? code = data['code'];
49
            final String? message = data['message'];
50
            final String? description = data['description'];
51
            // 输出日志
52
            _logger.i(
53
              'Response Code: $code, Message: $message, Description: $description',
54
            );
55

56
            // 处理 Token 过期 / 无效 / 未授权 (10001, 20301, 20302, 20303)
57
            if (code == 10001 ||
58
                code == 20301 ||
59
                code == 20302 ||
60
                code == 20303) {
61
              // 如果是刷新 Token 接口本身报错，直接抛出，不进行重试以免死循环
62
              if (response.requestOptions.path.contains('/refresh-token')) {
63
                return handler.reject(
64
                  DioException(
65
                    requestOptions: response.requestOptions,
66
                    error: message,
67
                    type: DioExceptionType.badResponse,
68
                    response: response,
69
                  ),
70
                );
71
              }
72

73
              if (_isRefreshing) {
74
                // 正在刷新中，等待完成
75
                try {
76
                  await _refreshCompleter?.future;
77
                  // 刷新成功后重试
78
                  final retryResponse = await _retry(response.requestOptions);
79
                  return handler.resolve(retryResponse);
80
                } catch (e) {
81
                  // 刷新失败，跟随失败
82
                  return handler.reject(
83
                    DioException(
84
                      requestOptions: response.requestOptions,
85
                      error: 'Token refresh failed',
86
                      type: DioExceptionType.badResponse,
87
                      response: response,
88
                    ),
89
                  );
90
                }
91
              }
92

93
              // 开始刷新
94
              _isRefreshing = true;
95
              _refreshCompleter = Completer<void>();
96

97
              try {
98
                final refreshToken = UserService.to.token?.refreshToken;
99
                if (refreshToken == null) {
100
                  throw Exception("No refresh token available");
101
                }
102

103
                // 调用刷新接口
104
                final newToken = await UserApi.refreshToken(refreshToken);
105
                // 保存新 Token
106
                await UserService.to.saveToken(newToken);
107

108
                _refreshCompleter?.complete();
109
                _isRefreshing = false;
110

111
                // 重试当前请求
112
                final retryResponse = await _retry(response.requestOptions);
113
                return handler.resolve(retryResponse);
114
              } catch (e) {
115
                _logger.e("Auto refresh token failed: $e");
116
                _refreshCompleter?.completeError(e);
117
                _isRefreshing = false;
118

119
                // 刷新失败，强制退出
120
                UserService.to.logout();
121

122
                return handler.reject(
123
                  DioException(
124
                    requestOptions: response.requestOptions,
125
                    error: 'Session expired, please login again.',
126
                    type: DioExceptionType.badResponse,
127
                    response: response,
128
                  ),
129
                );
130
              }
131
            }
132

133
            // 200 表示成功，视后端定义而定。
134
            if (code != null && code != GlobalConstants.successCode) {
135
              // 抛出业务异常
136
              // 优先显示 description, 如果没有才显示 message
137
              final errorMsg = (description != null && description.isNotEmpty)
138
                  ? description
139
                  : (message ?? 'common_error'.tr);
140

141
              SmartDialog.showToast(errorMsg);
142
              // 构造一个 DioException 抛给上层或者直接 reject
143
              return handler.reject(
144
                DioException(
145
                  requestOptions: response.requestOptions,
146
                  error: errorMsg,
147
                  type: DioExceptionType.badResponse,
148
                  response: response,
149
                ),
150
              );
151
            } else if (code == GlobalConstants.successCode) {
152
              // 不再自动解包 data，而是返回完整 Result 结构给上层
153
              // 由 HttpUtils.get/post 根据泛型 T 解析
154
            }
155
          }
156
          return handler.next(response);
157
        },
158
        onError: (DioException e, handler) {
159
          _handleError(e);
160
          return handler.next(e);
161
        },
162
      ),
163
    );
164
  }
165

166
  /// 重试请求
167
  Future<Response<dynamic>> _retry(RequestOptions requestOptions) async {
168
    final options = Options(
169
      method: requestOptions.method,
170
      headers: requestOptions.headers,
171
    );
172
    // 重试时，Token 会在 onRequest 中重新获取最新的
173
    return _dio.request<dynamic>(
174
      requestOptions.path,
175
      data: requestOptions.data,
176
      queryParameters: requestOptions.queryParameters,
177
      options: options,
178
    );
179
  }
180

181
  /// GET 请求
182
  Future<Result<T>> get<T>(
183
    String path, {
184
    Map<String, dynamic>? params,
185
    bool showLoading = true,
186
    T Function(Object? json)? fromJson,
187
  }) async {
188
    if (showLoading) {
189
      SmartDialog.showLoading(msg: 'common_loading'.tr); // 结合 i18n
190
    }
191
    try {
192
      final response = await _dio.get(path, queryParameters: params);
193
      return Result.fromJson(
194
        response.data,
195
        fromJson ?? (json) => json as T,
196
      );
197
    } catch (e) {
198
      rethrow;
199
    } finally {
200
      if (showLoading) SmartDialog.dismiss();
201
    }
202
  }
203

204
  /// POST 请求
205
  Future<Result<T>> post<T>(
206
    String path, {
207
    dynamic data,
208
    Map<String, dynamic>? params,
209
    bool showLoading = true,
210
    T Function(Object? json)? fromJson,
211
  }) async {
212
    if (showLoading) SmartDialog.showLoading(msg: 'common_loading'.tr);
213
    try {
214
      final response = await _dio.post(
215
        path,
216
        data: data,
217
        queryParameters: params,
218
      );
219
      return Result.fromJson(
220
        response.data,
221
        fromJson ?? (json) => json as T,
222
      );
223
    } catch (e) {
224
      rethrow;
225
    } finally {
226
      if (showLoading) SmartDialog.dismiss();
227
    }
228
  }
229

230
  // 错误处理
231
  void _handleError(DioException e) {
232
    String msg = "common_error".tr;
233
    if (e.type == DioExceptionType.connectionTimeout) {
234
      msg = "Connect Timeout";
235
    } else if (e.response != null) {
236
      // 这里的 response.data 可能是后端返回的 Result JSON，也可能是一个 error page
237
      // 如果 onResponse 已经 reject 了，这里会接收到
238
      // 如果是业务异常，msg 已经在 onResponse 中取过了，但 DioException 中 error 属性可能就是那个 msg
239
      if (e.error is String) {
240
        msg = e.error as String;
241
      } else {
242
        msg = "Server Error: ${e.response?.statusCode}";
243
      }
244
    } else if (e.error != null) {
245
      msg = e.error.toString();
246
    }
247
    _logger.e(msg);
248
    SmartDialog.showToast(msg);
249
  }
250
}

1
  static Future<Token> login(UserLoginDTO params) async {
2
    var result = await HttpUtils().post<Token>(
3
      '/user/login',
4
      data: params.toJson(),
5
      fromJson: (json) => Token.fromJson(json as Map<String, dynamic>),
6
    );
7
    // HttpUtils 内部拦截器会在 code!=200 时抛出异常
8
    // 所以这里的 data 一定不为 null
9
    return result.data!;
10
  }
11

12
  static Future<Token> refreshToken(String refreshToken) async {
13
    var result = await HttpUtils().post<Token>(
14
      '/user/refresh-token',
15
      data: RefreshTokenDTO(refreshToken: refreshToken).toJson(),
16
      showLoading: false, // 静默刷新
17
      fromJson: (json) => Token.fromJson(json as Map<String, dynamic>),
18
    );
19
    return result.data!;
20
  }

1
    // 在 Global.init() 或 main() 中
2
    // 注意：Freezed 生成的 Adapter 名称通常带有 Impl 后缀
3
    Hive.registerAdapter(TaskMasterImplAdapter());
4
    Hive.registerAdapter(TaskInstanceImplAdapter());
5
    Hive.registerAdapter(TaskMasterStatusAdapter());
6
    Hive.registerAdapter(TaskPriorityAdapter());
7
    Hive.registerAdapter(TaskInstanceStatusAdapter());
8
    Hive.registerAdapter(TaskExecutionTypeAdapter());
9
    Hive.registerAdapter(TaskExecutionConfigImplAdapter());
10
    Hive.registerAdapter(TaskRemindConfigImplAdapter());
11

12
    // 然后打开盒子
13
    // 注意：存入时使用具体类型，或者确保 Hive 能识别
14
    await Hive.openBox<TaskMaster>('task_masters');
15
    await Hive.openBox<TaskInstance>('task_instances');

1
// 1. 收集页面数据 (通常在 Controller 中)
2
final String title = titleController.text;
3
final String uuid = const Uuid().v7(); // 生成唯一ID
4

5
// 2. 构建对象 (使用 Freezed 的构造函数)
6
final newTask = TaskMaster(
7
  id: uuid,
8
  title: title,
9
  description: "这是描述...",
10
  status: TaskMasterStatus.inUse,
11
  createdAt: DateTime.now(),
12
  updatedAt: DateTime.now(),
13
  // 如果有配置对象
14
  executionConfig: const TaskExecutionConfig(
15
    type: TaskExecutionType.quota,
16
    target: 5,
17
  ),
18
  // ... 其他字段
19
);
20

21
// 3. 存入 Hive
22
final box = Hive.box<TaskMaster>('task_masters');
23
// 使用 id 作为 key，方便根据 ID 快速查找和覆盖更新
24
await box.put(newTask.id, newTask);

1
final box = Hive.box<TaskMaster>('task_masters');
2

3
// box.values 获取所有对象
4
final List<TaskMaster> highPriorityTasks = box.values
5
    .where((task) =>
6
        task.status == TaskMasterStatus.inUse &&
7
        task.priority == TaskPriority.high
8
    )
9
    .toList();
10

11
// 如果需要排序，例如按创建时间倒序
12
highPriorityTasks.sort((a, b) => b.createdAt!.compareTo(a.createdAt!));

1
class TaskController extends GetxController {
2
  // 定义一个可观察的列表
3
  final RxList<TaskMaster> tasks = <TaskMaster>[].obs;
4

5
  @override
6
  void onInit() {
7
    super.onInit();
8
    loadTasks();
9
  }
10

11
  void loadTasks() {
12
    final box = Hive.box<TaskMaster>('task_masters');
13
    // 转换 values 为 list 并赋值给 obs
14
    tasks.value = box.values.toList();
15
  }
16

17
  void addTask(TaskMaster task) async {
18
    final box = Hive.box<TaskMaster>('task_masters');
19
    await box.put(task.id, task);
20
    loadTasks(); // 重新加载刷新列表
21
    // 或者直接 tasks.add(task); 进行局部刷新
22
  }
23
}

1
// 在页面中使用 Obx 监听
2
Obx(() {
3
  if (controller.tasks.isEmpty) return EmptyView();
4

5
  return ListView.builder(
6
    itemCount: controller.tasks.length,
7
    itemBuilder: (context, index) {
8
      final task = controller.tasks[index];
9
      return ListTile(
10
        title: Text(task.title ?? "无标题"),
11
        subtitle: Text("类型: ${task.executionConfig?.type}"),
12
      );
13
    },
14
  );
15
})

1
// 1. 定义 API (在 user_api.dart 或新建 task_api.dart)
2
class TaskApi {
3
  static Future<void> createTask(TaskMaster task) async {
4
    // 自动调用 task.toJson() 转换为 Map
5
    await HttpUtils().post('/task/master', data: task.toJson());
6
  }
7
}
8

9
// 2. 调用 API (在 Controller 或 Service 中)
10
Future<void> syncTask(TaskMaster task) async {
11
  try {
12
    await TaskApi.createTask(task);
13

14
    // 3. 成功后更新本地状态
15
    // 将 synced 标记为 true，更新最后同步时间
16
    final syncedTask = task.copyWith(
17
      synced: true,
18
      lastSyncedAt: DateTime.now(),
19
    );
20

21
    // 更新本地数据库
22
    final box = Hive.box<TaskMaster>('task_masters');
23
    await box.put(syncedTask.id, syncedTask);
24

25
  } catch (e) {
26
    // 处理同步失败（例如网络不通），本地依旧保存，但 synced 为 false
27
    // 等网络恢复后再次同步
28
  }
29
}