ChickenFarm/UI/CF.APP/chicken_farm/lib/stores/auth_store.dart

import 'package:chicken_farm/apis/index.dart';
import 'package:chicken_farm/core/config/app_config.dart';
import 'package:chicken_farm/core/services/navigation_service.dart';
import 'package:chicken_farm/core/utils/jwt_token.dart';
import 'package:chicken_farm/core/utils/logger.dart';
import 'package:chicken_farm/modes/auth/login_model.dart';
import 'package:chicken_farm/modes/user/user_model.dart';
import 'package:chicken_farm/routes/app_routes.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:go_router/go_router.dart';

/// 认证状态枚举
enum AuthState { authenticated, unauthenticated, loading }

/// 用户认证信息状态
class AuthInfo {
  final AuthState state;
  final String? token;
  final UserModel? user;
  final List<String>? permissions;
  final List<String>? roles;

  AuthInfo({
    required this.state,
    this.token,
    this.user,
    this.permissions,
    this.roles,
  });

  /// 创建已认证状态
  AuthInfo.authenticated({
    required String token,
    required UserModel user,
    List<String>? permissions,
    List<String>? roles,
  }) : this(
         state: AuthState.authenticated,
         token: token,
         user: user,
         permissions: permissions,
         roles: roles,
       );

  /// 创建未认证状态
  AuthInfo.unauthenticated()
    : this(
        state: AuthState.unauthenticated,
        token: null,
        user: null,
        permissions: const [],
        roles: const [],
      );

  /// 创建加载状态
  AuthInfo.loading()
    : this(
        state: AuthState.loading,
        token: null,
        user: null,
        permissions: const [],
        roles: const [],
      );

  /// 复制对象并更新部分字段
  AuthInfo copyWith({
    AuthState? state,
    String? token,
    UserModel? user,
    List<String>? permissions,
    List<String>? roles,
  }) {
    return AuthInfo(
      state: state ?? this.state,
      token: token ?? this.token,
      user: user ?? this.user,
      permissions: permissions ?? this.permissions,
      roles: roles ?? this.roles,
    );
  }
}

class AuthStore extends StateNotifier<AuthInfo> {
  AuthStore() : super(AuthInfo.unauthenticated()) {
    _init();
  }

  /// 初始化认证状态
  Future<void> _init() async {
    state = AuthInfo.loading();
    try {
      final token = await JwtToken.getToken();
      if (token != null) {
        // 如果有token，则设置为已认证状态
        // 尝试获取用户信息以验证token有效性
        try {
          final userInfo = await apis.loginApi.getInfo();
          if (userInfo == null) {
            throw Exception('用户信息获取失败');
          }
          state = AuthInfo.authenticated(
            token: token,
            user: userInfo.user!,
            permissions: userInfo.permissions,
            roles: userInfo.roles,
          );
          logger.i('已登录 state: $state');
        } catch (e) {
          // Token无效，清除本地存储
          await JwtToken.clear();
          state = AuthInfo.unauthenticated();
        }
      } else {
        state = AuthInfo.unauthenticated();
      }
    } catch (e) {
      state = AuthInfo.unauthenticated();
    }
  }

  /// 登录操作
  Future<void> login(LoginModel loginModel) async {
    state = AuthInfo.loading();
    try {
      loginModel.clientId = AppConfig.clientId;
      final authResult = await apis.loginApi.login(loginModel);
      final token = authResult.accessToken;
      await JwtToken.setToken(token, authResult.refreshToken);
      // 获取用户信息
      final userInfo = await apis.loginApi.getInfo();
      if (userInfo == null) {
        throw Exception('用户信息获取失败');
      }
      state = AuthInfo.authenticated(
        token: token,
        user: userInfo.user!,
        permissions: userInfo.permissions,
        roles: userInfo.roles,
      );
      logger.i('登录成功 state: $state');
    } catch (e) {
      await JwtToken.clear();
      state = AuthInfo.unauthenticated();
    }
  }

  /// 登出操作
  Future<void> logout() async {
    try {
      await apis.loginApi.logout();
    } catch (e) {
      // 即使API调用失败也要清除本地状态
      logger.e('Logout API call failed: $e');
    } finally {
      await JwtToken.clear();
      state = AuthInfo.unauthenticated();
      if (NavigationService.navigatorKey.currentState != null &&
          NavigationService.navigatorKey.currentContext != null) {
        NavigationService.navigatorKey.currentContext!.goNamed(
          AppRouteNames.login,
        );
      }
    }
  }

  /// 刷新token
  Future<void> refreshToken() async {
    try {
      final refreshToken = await JwtToken.getRefreshToken();
      if (refreshToken != null) {
        final authResult = await apis.loginApi.refreshToken(refreshToken);
        final newToken = authResult.accessToken;
        await JwtToken.setToken(newToken, authResult.refreshToken);
        state = state.copyWith(token: newToken);
      }
    } catch (e) {
      // 刷新失败则登出
      await logout();
      rethrow;
    }
  }

  /// 重新获取用户信息
  Future<void> getUserInfo() async {
    try {
      final userInfo = await apis.loginApi.getInfo();
      if (userInfo == null) {
        throw Exception('用户信息获取失败');
      }
      state = state.copyWith(
        user: userInfo.user,
        permissions: userInfo.permissions,
        roles: userInfo.roles,
      );
    } catch (e) {
      rethrow;
    }
  }

  /// 检查是否有特定权限
  bool hasPermission(String permission) {
    return state.permissions?.contains(permission) ?? false;
  }

  /// 检查是否有特定角色
  bool hasRole(String role) {
    return state.roles?.contains(role) ?? false;
  }

  /// 是否是超级管理员
  bool isSuperAdmin() {
    if (state.user == null) return false;
    return state.user!.userName == "admin" ||
        (state.roles?.contains("super_admin") ?? false);
  }
}

// 添加 Provider 实例
final authStoreProvider = StateNotifierProvider<AuthStore, AuthInfo>(
  (ref) => AuthStore(),
);