import 'dart:convert';
import 'package:shared_preferences/shared_preferences.dart';
import '../../core/constants/api_constants.dart';
import '../../core/utils/crypto_utils.dart';
import '../datasources/remote/api_client.dart';
import '../models/auth/secure_login_request.dart';
import '../models/user.dart';
import '../models/auth/login_request.dart';
import '../models/auth/register_request.dart';
import '../models/auth/token_response.dart';
import '../models/api_response.dart';

class AuthRepository {
  final ApiClient _apiClient;
  final SharedPreferences _prefs;
  
  AuthRepository({
    required ApiClient apiClient,
    required SharedPreferences prefs,
  }) : _apiClient = apiClient, _prefs = prefs;
  
  // 登录（需要使用安全登录替代）
  Future<ApiResponse<User>> login(LoginRequest request) async {
    try {
      final response = await _apiClient.post(
        ApiConstants.getLoginUrl(),
        request.toJson(),
        withAuth: false,
      );
      
      if (response.statusCode == 200) {
        final tokenResponse = TokenResponse.fromJson(
          json.decode(response.body)
        );
        
        // 保存token
        await _apiClient.saveToken(tokenResponse.accessToken);
        
        return ApiResponse<User>(
          success: true,
          message: '登录成功',
          data: tokenResponse.user,
        );
      } else {
        final error = json.decode(response.body);
        return ApiResponse<User>(
          success: false,
          message: error['detail'] ?? '登录失败',
        );
      }
    } catch (e) {
      return ApiResponse<User>(
        success: false,
        message: '登录失败: $e',
      );
    }
  }
  
  // 注册（需要使用安全注册替代）
  Future<ApiResponse<User>> register(RegisterRequest request) async {
    try {
      final response = await _apiClient.post(
        ApiConstants.getRegisterUrl(),
        request.toJson(),
        withAuth: false,
      );
      
      if (response.statusCode == 201) {
        final tokenResponse = TokenResponse.fromJson(
          json.decode(response.body)
        );
        
        // 保存token
        await _apiClient.saveToken(tokenResponse.accessToken);
        
        return ApiResponse<User>(
          success: true,
          message: '注册成功',
          data: tokenResponse.user,
        );
      } else {
        final error = json.decode(response.body);
        return ApiResponse<User>(
          success: false,
          message: error['detail'] ?? '注册失败',
        );
      }
    } catch (e) {
      return ApiResponse<User>(
        success: false,
        message: '注册失败: $e',
      );
    }
  }
  
  // 安全登录方法
  Future<ApiResponse<User>> secureLogin(LoginRequest request) async {
    try {
      // 创建安全登录请求
      final secureRequest = SecureLoginRequest.create(
        username: request.username,
        password: request.password,
      );

      print(ApiConstants.getLoginUrl());
      print(secureRequest.toJson());
      
      final response = await _apiClient.post(
        ApiConstants.getLoginUrl(),
        secureRequest.toJson(),
        withAuth: false,
      );
      print(response.statusCode);
      
      // ... 处理响应
      if (response.statusCode == 200) {
        final tokenResponse = TokenResponse.fromJson(
          json.decode(response.body)
        );
        
        // 保存token
        await _apiClient.saveToken(tokenResponse.accessToken);
        
        return ApiResponse<User>(
          success: true,
          message: '登录成功',
          data: tokenResponse.user,
        );
      } else {
        final error = json.decode(response.body);
        return ApiResponse<User>(
          success: false,
          message: error['detail'] ?? '登录失败',
        );
      }
    } catch (e) {
      return ApiResponse<User>(
        success: false,
        message: '登录失败: $e',
      );
    }
  }
  
  // 安全注册方法
  Future<ApiResponse<User>> secureRegister(RegisterRequest request) async {
    try {
      // 创建安全注册数据
      final salt = CryptoUtils.generateSalt();
      final passwordHash = CryptoUtils.sha256Hash(request.password + salt);
      
      final registerData = {
        'username': request.username,
        'email': request.email,
        'password_hash': passwordHash,
        'salt': salt,
        'full_name': request.fullName,
        'password_confirm': request.passwordConfirm,
      };
      
      final response = await _apiClient.post(
        ApiConstants.getRegisterUrl(),
        registerData,
        withAuth: false,
      );
      
      // ... 处理响应
      if (response.statusCode == 201) {
        final tokenResponse = TokenResponse.fromJson(
          json.decode(response.body)
        );
        
        // 保存token
        await _apiClient.saveToken(tokenResponse.accessToken);
        
        return ApiResponse<User>(
          success: true,
          message: '注册成功',
          data: tokenResponse.user,
        );
      } else {
        final error = json.decode(response.body);
        return ApiResponse<User>(
          success: false,
          message: error['detail'] ?? '注册失败',
        );
      }
    } catch (e) {
      return ApiResponse<User>(
        success: false,
        message: '注册失败: $e',
      );
    }
  }

  // 获取当前用户
  Future<ApiResponse<User>> getCurrentUser() async {
    try {
      final response = await _apiClient.get(
        ApiConstants.getCurrentUserUrl(),
        withAuth: true,
      );
      
      if (response.statusCode == 200) {
        final userData = json.decode(response.body);
        return ApiResponse<User>(
          success: true,
          message: '获取成功',
          data: User.fromJson(userData),
        );
      } else {
        return ApiResponse<User>(
          success: false,
          message: '获取用户信息失败',
        );
      }
    } catch (e) {
      return ApiResponse<User>(
        success: false,
        message: '获取失败: $e',
      );
    }
  }
  
  // 登出
  Future<bool> logout() async {
    try {
      final response = await _apiClient.post(
        ApiConstants.getLogoutUrl(),
        {},
        withAuth: true,
      );
      
      if (response.statusCode == 200) {
        await _apiClient.clearToken();
        return true;
      }
      return false;
    } catch (e) {
      return false;
    }
  }
  
  // 检查登录状态
  Future<bool> isLoggedIn() async {
    return _apiClient.isLoggedIn();
  }
}